@ma7moudsalama/falak-app 1.0.0

package/template/src/composables/useDatabase.js

@@ -0,0 +1,341 @@
+/**
+ * useDatabase — Realtime Database Manager with Offline Support
+ * ─────────────────────────────────────────────────────────────
+ * Features:
+ *  • Reads/writes to Firebase Realtime Database
+ *  • Mirrors data in IndexedDB for offline access
+ *  • Detects online/offline status — blocks writes when offline
+ *  • Listens for remote changes and syncs to IndexedDB automatically
+ *  • Optional field-level encryption via useCrypto
+ *
+ * Usage:
+ *   const db = useDatabase()
+ *   const todos = await db.listen('todos')    // reactive ref + live sync
+ *   await db.set('todos/1', { title: 'Buy milk' })
+ *   await db.update('todos/1', { done: true })
+ *   await db.remove('todos/1')
+ *   const item = await db.get('todos/1')
+ */
+
+import { ref, readonly, onUnmounted } from 'vue'
+import {
+  ref as dbRef,
+  get,
+  set,
+  update,
+  remove,
+  push,
+  onValue,
+  onChildAdded,
+  onChildChanged,
+  onChildRemoved,
+  serverTimestamp,
+  query,
+  orderByChild,
+  equalTo,
+  limitToLast,
+  limitToFirst
+} from 'firebase/database'
+import { openDB } from 'idb'
+import { rtdb } from '@/firebase/index.js'
+import { useCrypto } from './useCrypto.js'
+
+// ── IndexedDB Setup ───────────────────────────
+const IDB_NAME    = 'falak_offline_db'
+const IDB_VERSION = 1
+
+async function getIDB() {
+  return openDB(IDB_NAME, IDB_VERSION, {
+    upgrade(db) {
+      if (!db.objectStoreNames.contains('cache')) {
+        const store = db.createObjectStore('cache', { keyPath: 'path' })
+        store.createIndex('updatedAt', 'updatedAt')
+      }
+      if (!db.objectStoreNames.contains('pending_writes')) {
+        db.createObjectStore('pending_writes', { keyPath: 'id', autoIncrement: true })
+      }
+    }
+  })
+}
+
+// ── Online Status ─────────────────────────────
+const isOnline = ref(navigator.onLine)
+window.addEventListener('online',  () => { isOnline.value = true  })
+window.addEventListener('offline', () => { isOnline.value = false })
+
+// ── Active listeners registry ─────────────────
+const listeners = new Map()
+
+export function useDatabase(options = {}) {
+  const {
+    encryptedPaths = [],   // ['users/*/email', 'payments/*']
+    encryptFields: encryptFieldsList = []  // field names to encrypt
+  } = options
+
+  const { encrypt, decrypt, encryptFields, decryptFields } = useCrypto()
+  const unsubscribers = []
+
+  // ── Helpers ────────────────────────────────
+  function shouldEncrypt(path) {
+    return encryptedPaths.some((pattern) => {
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '[^/]+') + '$')
+      return regex.test(path)
+    })
+  }
+
+  function prepareForWrite(path, data) {
+    if (!data || typeof data !== 'object') return data
+    return shouldEncrypt(path) || encryptFieldsList.length
+      ? encryptFields(data, encryptFieldsList)
+      : data
+  }
+
+  function prepareForRead(path, data) {
+    if (!data || typeof data !== 'object') return data
+    return shouldEncrypt(path) || encryptFieldsList.length
+      ? decryptFields(data, encryptFieldsList)
+      : data
+  }
+
+  // ── IndexedDB Helpers ─────────────────────
+  async function idbGet(path) {
+    const db   = await getIDB()
+    const item = await db.get('cache', path)
+    return item ? prepareForRead(path, item.data) : null
+  }
+
+  async function idbSet(path, data) {
+    const db = await getIDB()
+    await db.put('cache', { path, data, updatedAt: Date.now() })
+  }
+
+  async function idbDelete(path) {
+    const db = await getIDB()
+    await db.delete('cache', path)
+  }
+
+  async function idbGetAll(prefix) {
+    const db    = await getIDB()
+    const all   = await db.getAll('cache')
+    return all
+      .filter(item => item.path.startsWith(prefix))
+      .reduce((acc, item) => {
+        const key = item.path.replace(prefix + '/', '')
+        acc[key] = prepareForRead(item.path, item.data)
+        return acc
+      }, {})
+  }
+
+  // ── READ ───────────────────────────────────
+  /**
+   * One-time read. Returns offline data if offline.
+   */
+  async function get$(path) {
+    if (!isOnline.value) {
+      return idbGet(path)
+    }
+    const snap = await get(dbRef(rtdb, path))
+    const data = snap.exists() ? snap.val() : null
+    if (data) await idbSet(path, data)
+    return prepareForRead(path, data)
+  }
+
+  // ── WRITE ──────────────────────────────────
+  /**
+   * Set data at path. Blocked offline.
+   */
+  async function set$(path, data) {
+    if (!isOnline.value) {
+      return { success: false, error: 'You are offline. Data is read-only.' }
+    }
+    try {
+      const prepared = prepareForWrite(path, data)
+      await set(dbRef(rtdb, path), {
+        ...prepared,
+        updatedAt: serverTimestamp()
+      })
+      await idbSet(path, data)
+      return { success: true }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * Update (merge) data at path. Blocked offline.
+   */
+  async function update$(path, data) {
+    if (!isOnline.value) {
+      return { success: false, error: 'You are offline. Data is read-only.' }
+    }
+    try {
+      const prepared = prepareForWrite(path, data)
+      await update(dbRef(rtdb, path), {
+        ...prepared,
+        updatedAt: serverTimestamp()
+      })
+      // Merge into IDB cache
+      const existing = await idbGet(path) || {}
+      await idbSet(path, { ...existing, ...data })
+      return { success: true }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * Push new child to a list. Blocked offline.
+   */
+  async function push$(path, data) {
+    if (!isOnline.value) {
+      return { success: false, error: 'You are offline. Data is read-only.' }
+    }
+    try {
+      const prepared = prepareForWrite(path, data)
+      const newRef = await push(dbRef(rtdb, path), {
+        ...prepared,
+        createdAt: serverTimestamp()
+      })
+      await idbSet(`${path}/${newRef.key}`, data)
+      return { success: true, key: newRef.key }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * Remove data at path. Blocked offline.
+   */
+  async function remove$(path) {
+    if (!isOnline.value) {
+      return { success: false, error: 'You are offline. Data is read-only.' }
+    }
+    try {
+      await remove(dbRef(rtdb, path))
+      await idbDelete(path)
+      return { success: true }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  // ── REAL-TIME LISTENER ─────────────────────
+  /**
+   * Subscribe to a path. Returns reactive ref updated live.
+   * Also syncs to IndexedDB on every remote change.
+   *
+   * @param {string} path - RTDB path
+   * @param {object} queryOptions - { orderBy, equalTo, limit, limitMode }
+   * @returns {{ data: Ref, unsubscribe: Function }}
+   */
+  function listen(path, queryOptions = {}) {
+    const data = ref(null)
+
+    // Preload from IDB
+    idbGet(path).then((cached) => {
+      if (cached && data.value === null) data.value = cached
+    })
+
+    let q = dbRef(rtdb, path)
+    if (queryOptions.orderBy) {
+      q = query(q, orderByChild(queryOptions.orderBy))
+    }
+    if (queryOptions.equalTo !== undefined) {
+      q = query(q, equalTo(queryOptions.equalTo))
+    }
+    if (queryOptions.limit) {
+      q = queryOptions.limitMode === 'first'
+        ? query(q, limitToFirst(queryOptions.limit))
+        : query(q, limitToLast(queryOptions.limit))
+    }
+
+    const unsub = onValue(q, async (snap) => {
+      const val = snap.exists() ? snap.val() : null
+      if (val) await idbSet(path, val)
+      data.value = prepareForRead(path, val)
+    })
+
+    unsubscribers.push(unsub)
+
+    return {
+      data: readonly(data),
+      unsubscribe: unsub
+    }
+  }
+
+  /**
+   * Listen to child-level events (added/changed/removed) on a list.
+   * More efficient than listening to the whole list.
+   *
+   * @returns {{ items: Ref<Object>, unsubscribe: Function }}
+   */
+  function listenList(path) {
+    const items = ref({})
+
+    // Preload from IDB
+    idbGetAll(path).then((cached) => {
+      if (Object.keys(cached).length && Object.keys(items.value).length === 0) {
+        items.value = cached
+      }
+    })
+
+    const baseRef = dbRef(rtdb, path)
+
+    const u1 = onChildAdded(baseRef, async (snap) => {
+      const key = snap.key
+      const val = prepareForRead(`${path}/${key}`, snap.val())
+      items.value = { ...items.value, [key]: val }
+      await idbSet(`${path}/${key}`, snap.val())
+    })
+
+    const u2 = onChildChanged(baseRef, async (snap) => {
+      const key = snap.key
+      const val = prepareForRead(`${path}/${key}`, snap.val())
+      items.value = { ...items.value, [key]: val }
+      await idbSet(`${path}/${key}`, snap.val())
+    })
+
+    const u3 = onChildRemoved(baseRef, async (snap) => {
+      const key = snap.key
+      const copy = { ...items.value }
+      delete copy[key]
+      items.value = copy
+      await idbDelete(`${path}/${key}`)
+    })
+
+    const unsubscribe = () => { u1(); u2(); u3() }
+    unsubscribers.push(unsubscribe)
+
+    return { items, unsubscribe }
+  }
+
+  // ── Offline IDB-only read ──────────────────
+  async function getOffline(path) {
+    return idbGet(path)
+  }
+
+  async function getAllOffline(prefix) {
+    return idbGetAll(prefix)
+  }
+
+  // ── Cleanup on component unmount ───────────
+  onUnmounted(() => {
+    unsubscribers.forEach((u) => u())
+  })
+
+  return {
+    // State
+    isOnline: readonly(isOnline),
+
+    // Methods
+    get:          get$,
+    set:          set$,
+    update:       update$,
+    push:         push$,
+    remove:       remove$,
+    listen,
+    listenList,
+    getOffline,
+    getAllOffline
+  }
+}

package/template/src/composables/useGroq.js

@@ -0,0 +1,237 @@
+/**
+ * useGroq — Groq AI Composable
+ * ──────────────────────────────
+ * Wraps groq-sdk to provide chat completions, streaming, and
+ * a simple conversation history manager.
+ *
+ * Usage:
+ *   const groq = useGroq()
+ *   const reply = await groq.chat('What is Vue.js?')
+ *
+ *   // Streaming
+ *   await groq.streamChat('Tell me a story', (chunk) => console.log(chunk))
+ *
+ *   // Multi-turn conversation
+ *   groq.addMessage('user', 'Hello')
+ *   const reply = await groq.sendConversation()
+ */
+
+import Groq from 'groq-sdk'
+import { ref, readonly } from 'vue'
+
+const DEFAULT_MODEL  = import.meta.env.VITE_GROQ_MODEL  || 'llama-3.3-70b-versatile'
+const GROQ_API_KEY   = import.meta.env.VITE_GROQ_API_KEY || ''
+
+// Singleton client
+let _client = null
+function getClient() {
+  if (!_client) {
+    if (!GROQ_API_KEY) {
+      console.warn('[useGroq] VITE_GROQ_API_KEY is not set')
+    }
+    _client = new Groq({
+      apiKey:    GROQ_API_KEY,
+      dangerouslyAllowBrowser: true  // required for browser usage
+    })
+  }
+  return _client
+}
+
+export function useGroq(defaultSystemPrompt = null) {
+  const isLoading   = ref(false)
+  const lastError   = ref(null)
+  const messages    = ref([])  // conversation history
+
+  if (defaultSystemPrompt) {
+    messages.value = [{ role: 'system', content: defaultSystemPrompt }]
+  }
+
+  // ── Single completion ──────────────────────
+  /**
+   * Send a single prompt and get a response.
+   * Does NOT track conversation history.
+   */
+  async function chat(prompt, options = {}) {
+    isLoading.value = true
+    lastError.value = null
+    try {
+      const completion = await getClient().chat.completions.create({
+        model:       options.model       || DEFAULT_MODEL,
+        max_tokens:  options.maxTokens   || 1024,
+        temperature: options.temperature ?? 0.7,
+        messages: [
+          ...(options.systemPrompt
+            ? [{ role: 'system', content: options.systemPrompt }]
+            : []),
+          { role: 'user', content: prompt }
+        ]
+      })
+      return completion.choices[0]?.message?.content || ''
+    } catch (err) {
+      lastError.value = err.message
+      throw err
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // ── Streaming completion ───────────────────
+  /**
+   * Stream a response, calling onChunk for each token.
+   * @param {string} prompt
+   * @param {Function} onChunk - called with each text chunk
+   * @param {object} options
+   * @returns {Promise<string>} full response
+   */
+  async function streamChat(prompt, onChunk, options = {}) {
+    isLoading.value = true
+    lastError.value = null
+    let fullText = ''
+    try {
+      const stream = await getClient().chat.completions.create({
+        model:       options.model       || DEFAULT_MODEL,
+        max_tokens:  options.maxTokens   || 2048,
+        temperature: options.temperature ?? 0.7,
+        stream:      true,
+        messages: [
+          ...(options.systemPrompt
+            ? [{ role: 'system', content: options.systemPrompt }]
+            : []),
+          { role: 'user', content: prompt }
+        ]
+      })
+
+      for await (const chunk of stream) {
+        const text = chunk.choices[0]?.delta?.content || ''
+        if (text) {
+          fullText += text
+          onChunk(text, fullText)
+        }
+      }
+      return fullText
+    } catch (err) {
+      lastError.value = err.message
+      throw err
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // ── Multi-turn conversation ────────────────
+  function addMessage(role, content) {
+    messages.value.push({ role, content })
+  }
+
+  function setSystemPrompt(prompt) {
+    const idx = messages.value.findIndex(m => m.role === 'system')
+    if (idx >= 0) {
+      messages.value[idx].content = prompt
+    } else {
+      messages.value.unshift({ role: 'system', content: prompt })
+    }
+  }
+
+  function clearConversation(keepSystem = true) {
+    if (keepSystem) {
+      messages.value = messages.value.filter(m => m.role === 'system')
+    } else {
+      messages.value = []
+    }
+  }
+
+  /**
+   * Send current conversation history and get a reply.
+   * Automatically appends assistant reply to history.
+   */
+  async function sendConversation(userMessage = null, options = {}) {
+    if (userMessage) addMessage('user', userMessage)
+    isLoading.value = true
+    lastError.value = null
+    try {
+      const completion = await getClient().chat.completions.create({
+        model:       options.model       || DEFAULT_MODEL,
+        max_tokens:  options.maxTokens   || 1024,
+        temperature: options.temperature ?? 0.7,
+        messages:    messages.value
+      })
+      const reply = completion.choices[0]?.message?.content || ''
+      addMessage('assistant', reply)
+      return reply
+    } catch (err) {
+      lastError.value = err.message
+      throw err
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  /**
+   * Stream multi-turn conversation.
+   */
+  async function streamConversation(userMessage, onChunk, options = {}) {
+    addMessage('user', userMessage)
+    isLoading.value = true
+    lastError.value = null
+    let fullText = ''
+    try {
+      const stream = await getClient().chat.completions.create({
+        model:       options.model       || DEFAULT_MODEL,
+        max_tokens:  options.maxTokens   || 2048,
+        temperature: options.temperature ?? 0.7,
+        stream:      true,
+        messages:    messages.value
+      })
+      for await (const chunk of stream) {
+        const text = chunk.choices[0]?.delta?.content || ''
+        if (text) {
+          fullText += text
+          onChunk(text, fullText)
+        }
+      }
+      addMessage('assistant', fullText)
+      return fullText
+    } catch (err) {
+      lastError.value = err.message
+      throw err
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // ── Audio transcription ────────────────────
+  /**
+   * Transcribe an audio file (Blob or File) using Whisper.
+   */
+  async function transcribe(audioFile, language = 'en') {
+    isLoading.value = true
+    try {
+      const transcription = await getClient().audio.transcriptions.create({
+        file:     audioFile,
+        model:    'whisper-large-v3',
+        language,
+        response_format: 'json'
+      })
+      return transcription.text
+    } catch (err) {
+      lastError.value = err.message
+      throw err
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return {
+    isLoading: readonly(isLoading),
+    lastError: readonly(lastError),
+    messages:  readonly(messages),
+
+    chat,
+    streamChat,
+    sendConversation,
+    streamConversation,
+    addMessage,
+    setSystemPrompt,
+    clearConversation,
+    transcribe
+  }
+}