@morscherlab/mld-sdk 0.6.0

package/src/composables/useAuth.ts

@@ -0,0 +1,427 @@
+import axios from 'axios'
+import { ref, onMounted, onUnmounted, watch, type Ref } from 'vue'
+import { useAuthStore } from '../stores/auth'
+import { useSettingsStore } from '../stores/settings'
+import type { AuthConfig, UserInfo, LoginResponse, TokenVerifyResponse, UpdateProfileRequest } from '../types'
+
+interface UserResponse {
+  id: string
+  username: string
+  shortname: string | null
+  email: string | null
+  role: string
+  is_active: boolean
+}
+
+interface RefreshResponse {
+  access_token: string
+  expires_in: number
+  token_type: string
+}
+
+// Token refresh configuration
+const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000 // Refresh 5 minutes before expiry
+const TOKEN_REFRESH_CHECK_INTERVAL_MS = 60 * 1000 // Check every minute
+
+/**
+ * Authentication composable with automatic token refresh.
+ *
+ * Features:
+ * - Automatic token refresh before expiration
+ * - Login/logout/register functionality
+ * - Token verification on startup
+ * - User profile management
+ *
+ * @example
+ * ```typescript
+ * const { login, logout, isAuthenticated, user } = useAuth()
+ *
+ * // Login
+ * const success = await login('username', 'password')
+ *
+ * // Automatic refresh is enabled by default
+ * // Tokens are refreshed 5 minutes before expiration
+ * ```
+ */
+export interface UseAuthReturn {
+  login: (username: string, password: string) => Promise<boolean>
+  logout: () => void
+  register: (username: string, password: string, email?: string) => Promise<boolean>
+  verifyToken: () => Promise<boolean>
+  fetchAuthConfig: () => Promise<AuthConfig>
+  initializeAuth: () => Promise<void>
+  getCurrentUser: () => Promise<UserInfo | null>
+  getAuthHeader: () => Record<string, string>
+  updateProfile: (data: { email?: string; shortname?: string; currentPassword?: string; newPassword?: string }) => Promise<{ success: boolean; error?: string }>
+  refreshToken: () => Promise<boolean>
+  isRefreshing: Ref<boolean>
+}
+
+export function useAuth(): UseAuthReturn {
+  const authStore = useAuthStore()
+  const settingsStore = useSettingsStore()
+
+  // Track refresh timer
+  const refreshTimerId = ref<number | null>(null)
+  const isRefreshing = ref(false)
+
+  function getApiBaseUrl(): string {
+    return settingsStore.getApiBaseUrl()
+  }
+
+  async function fetchAuthConfig(): Promise<AuthConfig> {
+    try {
+      const response = await axios.get<{
+        auth_required: boolean
+        passkey_enabled: boolean
+        passkey_registered?: boolean
+        registration_enabled?: boolean
+        database_mode?: string
+      }>(`${getApiBaseUrl()}/setup/config/public`)
+
+      const config: AuthConfig = {
+        authRequired: response.data.auth_required,
+        passkeyEnabled: response.data.passkey_enabled,
+        passkeyRegistered: response.data.passkey_registered ?? false,
+        registrationEnabled: response.data.registration_enabled ?? false,
+        databaseMode: response.data.database_mode ?? 'none',
+      }
+
+      authStore.setAuthConfig(config)
+      return config
+    } catch (error) {
+      console.error('Failed to fetch auth config:', error)
+      return {
+        authRequired: false,
+        passkeyEnabled: false,
+        passkeyRegistered: false,
+        registrationEnabled: false,
+        databaseMode: 'none',
+      }
+    }
+  }
+
+  async function login(username: string, password: string): Promise<boolean> {
+    authStore.setLoading(true)
+    authStore.setError(null)
+
+    try {
+      const response = await axios.post<LoginResponse>(
+        `${getApiBaseUrl()}/auth/login`,
+        { username, password }
+      )
+
+      authStore.setToken(response.data.access_token, response.data.expires_in)
+      authStore.setUsername(username)
+
+      await getCurrentUser()
+
+      // Start auto-refresh after successful login
+      scheduleTokenRefresh()
+
+      return true
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response) {
+        authStore.setError(error.response.data.detail || 'Login failed')
+      } else {
+        authStore.setError('Network error. Please try again.')
+      }
+      return false
+    } finally {
+      authStore.setLoading(false)
+    }
+  }
+
+  async function register(username: string, password: string, email?: string): Promise<boolean> {
+    authStore.setLoading(true)
+    authStore.setError(null)
+
+    try {
+      await axios.post<UserResponse>(
+        `${getApiBaseUrl()}/users/register`,
+        { username, password, email }
+      )
+
+      return await login(username, password)
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response) {
+        authStore.setError(error.response.data.detail || 'Registration failed')
+      } else {
+        authStore.setError('Network error. Please try again.')
+      }
+      return false
+    } finally {
+      authStore.setLoading(false)
+    }
+  }
+
+  async function getCurrentUser(): Promise<UserInfo | null> {
+    if (!authStore.token) {
+      return null
+    }
+
+    try {
+      const response = await axios.get<UserResponse>(
+        `${getApiBaseUrl()}/users/me`,
+        { headers: getAuthHeader() }
+      )
+
+      const userInfo: UserInfo = {
+        id: response.data.id,
+        username: response.data.username,
+        shortname: response.data.shortname,
+        email: response.data.email,
+        role: response.data.role,
+        isActive: response.data.is_active,
+      }
+
+      authStore.setUserInfo(userInfo)
+      return userInfo
+    } catch {
+      return null
+    }
+  }
+
+  async function verifyToken(): Promise<boolean> {
+    if (!authStore.token) {
+      return false
+    }
+
+    try {
+      const response = await axios.get<TokenVerifyResponse>(
+        `${getApiBaseUrl()}/auth/verify`,
+        {
+          headers: {
+            Authorization: `Bearer ${authStore.token}`,
+          },
+        }
+      )
+
+      if (response.data.valid && response.data.username) {
+        authStore.setUsername(response.data.username)
+        return true
+      }
+
+      authStore.clearToken()
+      return false
+    } catch {
+      authStore.clearToken()
+      return false
+    }
+  }
+
+  /**
+   * Refresh the authentication token.
+   * Called automatically before token expiration.
+   * Uses promise caching to prevent concurrent refresh requests.
+   */
+  let refreshPromise: Promise<boolean> | null = null
+
+  async function refreshToken(): Promise<boolean> {
+    if (!authStore.token) return false
+    if (refreshPromise) return refreshPromise
+
+    refreshPromise = (async () => {
+      isRefreshing.value = true
+
+      try {
+        const response = await axios.post<RefreshResponse>(
+          `${getApiBaseUrl()}/auth/refresh`,
+          {},
+          { headers: getAuthHeader() }
+        )
+
+        authStore.setToken(response.data.access_token, response.data.expires_in)
+
+        // Reschedule next refresh
+        scheduleTokenRefresh()
+
+        return true
+      } catch (error) {
+        // If refresh fails, the token may have been revoked
+        // Clear auth state and let user re-login
+        if (axios.isAxiosError(error) && error.response?.status === 401) {
+          console.warn('[Auth] Token refresh failed - session expired')
+          authStore.clearToken()
+          stopTokenRefresh()
+        }
+        return false
+      } finally {
+        isRefreshing.value = false
+        refreshPromise = null
+      }
+    })()
+
+    return refreshPromise
+  }
+
+  /**
+   * Schedule automatic token refresh before expiration.
+   */
+  function scheduleTokenRefresh(): void {
+    // Clear any existing timer
+    stopTokenRefresh()
+
+    if (!authStore.tokenExpires) {
+      return
+    }
+
+    const expiresAt = authStore.tokenExpires.getTime()
+    const refreshAt = expiresAt - TOKEN_REFRESH_MARGIN_MS
+    const now = Date.now()
+
+    if (refreshAt <= now) {
+      // Token is already close to expiring or expired, refresh now
+      refreshToken()
+      return
+    }
+
+    // Schedule refresh
+    const delay = refreshAt - now
+    refreshTimerId.value = window.setTimeout(() => {
+      refreshToken()
+    }, delay)
+  }
+
+  /**
+   * Stop automatic token refresh.
+   */
+  function stopTokenRefresh(): void {
+    if (refreshTimerId.value !== null) {
+      window.clearTimeout(refreshTimerId.value)
+      refreshTimerId.value = null
+    }
+  }
+
+  /**
+   * Check if token needs refresh and refresh if necessary.
+   * Called periodically as a safety net.
+   */
+  function checkAndRefreshIfNeeded(): void {
+    if (!authStore.token || !authStore.tokenExpires) {
+      return
+    }
+
+    const expiresAt = authStore.tokenExpires.getTime()
+    const refreshAt = expiresAt - TOKEN_REFRESH_MARGIN_MS
+    const now = Date.now()
+
+    if (now >= refreshAt) {
+      refreshToken()
+    }
+  }
+
+  async function initializeAuth(): Promise<void> {
+    authStore.initialize()
+    await fetchAuthConfig()
+
+    if (authStore.token) {
+      const valid = await verifyToken()
+      if (valid) {
+        await getCurrentUser()
+        // Start auto-refresh for existing session
+        scheduleTokenRefresh()
+      }
+    }
+  }
+
+  function logout(): void {
+    stopTokenRefresh()
+    authStore.logout()
+  }
+
+  function getAuthHeader(): Record<string, string> {
+    if (authStore.token) {
+      return { Authorization: `Bearer ${authStore.token}` }
+    }
+    return {}
+  }
+
+  async function updateProfile(data: {
+    email?: string
+    shortname?: string
+    currentPassword?: string
+    newPassword?: string
+  }): Promise<{ success: boolean; error?: string }> {
+    if (!authStore.token) {
+      return { success: false, error: 'Not authenticated' }
+    }
+
+    try {
+      const requestData: UpdateProfileRequest = {}
+      if (data.email !== undefined) requestData.email = data.email
+      if (data.shortname !== undefined) requestData.shortname = data.shortname
+      if (data.currentPassword) requestData.current_password = data.currentPassword
+      if (data.newPassword) requestData.new_password = data.newPassword
+
+      const response = await axios.put<UserResponse>(
+        `${getApiBaseUrl()}/users/me`,
+        requestData,
+        { headers: getAuthHeader() }
+      )
+
+      const userInfo: UserInfo = {
+        id: response.data.id,
+        username: response.data.username,
+        shortname: response.data.shortname,
+        email: response.data.email,
+        role: response.data.role,
+        isActive: response.data.is_active,
+      }
+      authStore.setUserInfo(userInfo)
+
+      return { success: true }
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response) {
+        return { success: false, error: error.response.data.detail || 'Update failed' }
+      }
+      return { success: false, error: 'Network error. Please try again.' }
+    }
+  }
+
+  // Set up periodic check as safety net
+  let checkInterval: number | null = null
+
+  onMounted(() => {
+    // Start periodic check
+    checkInterval = window.setInterval(checkAndRefreshIfNeeded, TOKEN_REFRESH_CHECK_INTERVAL_MS)
+  })
+
+  onUnmounted(() => {
+    // Clean up on unmount
+    stopTokenRefresh()
+    if (checkInterval !== null) {
+      window.clearInterval(checkInterval)
+      checkInterval = null
+    }
+  })
+
+  // Watch for token changes to reschedule refresh
+  watch(
+    () => authStore.tokenExpires,
+    (newExpires) => {
+      if (newExpires) {
+        scheduleTokenRefresh()
+      } else {
+        stopTokenRefresh()
+      }
+    }
+  )
+
+  return {
+    // Core auth methods
+    login,
+    logout,
+    register,
+    verifyToken,
+    fetchAuthConfig,
+    initializeAuth,
+    getCurrentUser,
+    getAuthHeader,
+    updateProfile,
+
+    // Token refresh
+    refreshToken,
+    isRefreshing,
+  }
+}

package/src/composables/useChemicalFormula.ts

@@ -0,0 +1,274 @@
+// Types
+export interface ParsedElement {
+  symbol: string
+  count: number
+}
+
+export interface FormulaParseResult {
+  elements: Record<string, number>
+  valid: boolean
+  error?: string
+}
+
+export type FormulaPartType = 'element' | 'subscript' | 'superscript' | 'paren' | 'dot' | 'charge'
+
+export interface FormulaPart {
+  type: FormulaPartType
+  text: string
+}
+
+// ~30 common elements with atomic weights
+export const ATOMIC_WEIGHTS: Record<string, number> = {
+  H: 1.008, He: 4.003, Li: 6.941, Be: 9.012, B: 10.81,
+  C: 12.011, N: 14.007, O: 15.999, F: 18.998, Ne: 20.180,
+  Na: 22.990, Mg: 24.305, Al: 26.982, Si: 28.086, P: 30.974,
+  S: 32.065, Cl: 35.453, Ar: 39.948, K: 39.098, Ca: 40.078,
+  Mn: 54.938, Fe: 55.845, Co: 58.933, Ni: 58.693, Cu: 63.546,
+  Zn: 65.38, Br: 79.904, Ag: 107.868, I: 126.904, Au: 196.967,
+}
+
+function parseFormulaSegment(formula: string): FormulaParseResult {
+  const elements: Record<string, number> = {}
+  const stack: Record<string, number>[] = [{}]
+  let i = 0
+
+  while (i < formula.length) {
+    const ch = formula[i]
+
+    if (ch === '(') {
+      stack.push({})
+      i++
+    } else if (ch === ')') {
+      if (stack.length < 2) {
+        return { elements: {}, valid: false, error: 'Unmatched closing parenthesis' }
+      }
+      i++
+      // Read multiplier after closing paren
+      let numStr = ''
+      while (i < formula.length && /\d/.test(formula[i])) {
+        numStr += formula[i]
+        i++
+      }
+      const multiplier = numStr ? parseInt(numStr, 10) : 1
+      const top = stack.pop()!
+      const current = stack[stack.length - 1]
+      for (const [el, count] of Object.entries(top)) {
+        current[el] = (current[el] || 0) + count * multiplier
+      }
+    } else if (/[A-Z]/.test(ch)) {
+      // Element symbol: uppercase letter optionally followed by lowercase
+      let symbol = ch
+      i++
+      while (i < formula.length && /[a-z]/.test(formula[i])) {
+        symbol += formula[i]
+        i++
+      }
+      // Validate element
+      if (!(symbol in ATOMIC_WEIGHTS)) {
+        return { elements: {}, valid: false, error: `Unknown element: ${symbol}` }
+      }
+      // Read count
+      let numStr = ''
+      while (i < formula.length && /\d/.test(formula[i])) {
+        numStr += formula[i]
+        i++
+      }
+      const count = numStr ? parseInt(numStr, 10) : 1
+      const current = stack[stack.length - 1]
+      current[symbol] = (current[symbol] || 0) + count
+    } else {
+      return { elements: {}, valid: false, error: `Unexpected character: ${ch}` }
+    }
+  }
+
+  if (stack.length !== 1) {
+    return { elements: {}, valid: false, error: 'Unmatched opening parenthesis' }
+  }
+
+  Object.assign(elements, stack[0])
+  return { elements, valid: true }
+}
+
+export function useChemicalFormula() {
+  function parseFormula(formula: string): FormulaParseResult {
+    const trimmed = formula.trim()
+    if (!trimmed) {
+      return { elements: {}, valid: false, error: 'Empty formula' }
+    }
+
+    // Split on hydrate separator (· or .)
+    const parts = trimmed.split(/[·.]/)
+    const combined: Record<string, number> = {}
+
+    for (const part of parts) {
+      const segment = part.trim()
+      if (!segment) continue
+
+      // Check for leading coefficient (e.g., 5H2O)
+      let coefficient = 1
+      let formulaStr = segment
+      const coeffMatch = segment.match(/^(\d+)([A-Z].*)$/)
+      if (coeffMatch) {
+        coefficient = parseInt(coeffMatch[1], 10)
+        formulaStr = coeffMatch[2]
+      }
+
+      const result = parseFormulaSegment(formulaStr)
+      if (!result.valid) {
+        return result
+      }
+
+      for (const [el, count] of Object.entries(result.elements)) {
+        combined[el] = (combined[el] || 0) + count * coefficient
+      }
+    }
+
+    return { elements: combined, valid: true }
+  }
+
+  function calculateMW(elements: Record<string, number>): number {
+    let mw = 0
+    for (const [el, count] of Object.entries(elements)) {
+      const weight = ATOMIC_WEIGHTS[el]
+      if (weight !== undefined) {
+        mw += weight * count
+      }
+    }
+    return Math.round(mw * 1000) / 1000
+  }
+
+  function renderFormulaParts(formula: string): FormulaPart[] {
+    const parts: FormulaPart[] = []
+    const trimmed = formula.trim()
+    let i = 0
+
+    while (i < trimmed.length) {
+      const ch = trimmed[i]
+
+      // Hydrate dot separator
+      if (ch === '·' || (ch === '.' && i > 0 && /\d/.test(trimmed[i - 1]) && i + 1 < trimmed.length && /\d/.test(trimmed[i + 1]))) {
+        // Disambiguate: '.' as hydrate separator only if followed by a digit then uppercase
+        // For simplicity, treat '·' always as dot
+        if (ch === '·') {
+          parts.push({ type: 'dot', text: '·' })
+          i++
+          continue
+        }
+      }
+
+      // Parentheses
+      if (ch === '(' || ch === ')') {
+        parts.push({ type: 'paren', text: ch })
+        i++
+        // After ')' check for subscript number
+        if (ch === ')' && i < trimmed.length && /\d/.test(trimmed[i])) {
+          let numStr = ''
+          while (i < trimmed.length && /\d/.test(trimmed[i])) {
+            numStr += trimmed[i]
+            i++
+          }
+          parts.push({ type: 'subscript', text: numStr })
+        }
+        continue
+      }
+
+      // Charge notation: ^2+, ^2-, 2+, 2- at end, or +, -
+      if (ch === '^') {
+        i++
+        let chargeStr = ''
+        while (i < trimmed.length && /[\d+\-]/.test(trimmed[i])) {
+          chargeStr += trimmed[i]
+          i++
+        }
+        if (chargeStr) {
+          parts.push({ type: 'charge', text: chargeStr })
+        }
+        continue
+      }
+
+      // Element symbol: uppercase followed by optional lowercase
+      if (/[A-Z]/.test(ch)) {
+        let symbol = ch
+        i++
+        while (i < trimmed.length && /[a-z]/.test(trimmed[i])) {
+          symbol += trimmed[i]
+          i++
+        }
+        parts.push({ type: 'element', text: symbol })
+
+        // Check for subscript number after element
+        if (i < trimmed.length && /\d/.test(trimmed[i])) {
+          let numStr = ''
+          while (i < trimmed.length && /\d/.test(trimmed[i])) {
+            numStr += trimmed[i]
+            i++
+          }
+          parts.push({ type: 'subscript', text: numStr })
+
+          // Check for charge after subscript (e.g., Fe2+ or SO4^2-)
+          if (i < trimmed.length && (trimmed[i] === '+' || trimmed[i] === '-')) {
+            parts.push({ type: 'charge', text: numStr + trimmed[i] })
+            // Remove the subscript we just added since it's actually part of charge
+            // Actually, for cases like Fe2+, the 2+ is the charge, not a subscript
+            // But for H2O the 2 is a subscript. We need context.
+            // Simplification: if followed by +/-, treat trailing digits as part of charge
+            parts.splice(parts.length - 2, 1) // Remove the subscript
+            i++
+            continue
+          }
+        }
+        continue
+      }
+
+      // Leading digit (hydrate coefficient like 5H2O)
+      if (/\d/.test(ch)) {
+        let numStr = ''
+        while (i < trimmed.length && /\d/.test(trimmed[i])) {
+          numStr += trimmed[i]
+          i++
+        }
+        // Could be a subscript or coefficient depending on context
+        // If next char is uppercase, it's a coefficient (render as element-like text)
+        // If at end or followed by +/-, it's a charge component
+        if (i < trimmed.length && (trimmed[i] === '+' || trimmed[i] === '-')) {
+          parts.push({ type: 'charge', text: numStr + trimmed[i] })
+          i++
+        } else {
+          parts.push({ type: 'subscript', text: numStr })
+        }
+        continue
+      }
+
+      // Standalone + or - (charge)
+      if (ch === '+' || ch === '-') {
+        parts.push({ type: 'charge', text: ch })
+        i++
+        continue
+      }
+
+      // Dot as hydrate separator
+      if (ch === '.') {
+        parts.push({ type: 'dot', text: '·' })
+        i++
+        continue
+      }
+
+      // Skip whitespace
+      if (/\s/.test(ch)) {
+        i++
+        continue
+      }
+
+      // Unknown character, skip
+      i++
+    }
+
+    return parts
+  }
+
+  return {
+    parseFormula,
+    calculateMW,
+    renderFormulaParts,
+  }
+}