@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

package/src/composables/usePasskey.ts

@@ -1,216 +0,0 @@
-import axios from 'axios'
-import { useAuthStore } from '../stores/auth'
-import { useSettingsStore } from '../stores/settings'
-import type { CredentialInfo } from '../types'
-
-// Lazy-load @simplewebauthn/browser so plugins that never call usePasskey
-// don't need the optional peer dep installed (avoids build failures).
-async function loadWebAuthn() {
-  try {
-    return await import('@simplewebauthn/browser')
-  } catch {
-    throw new Error(
-      '@simplewebauthn/browser is required for passkey support. Install it: bun add @simplewebauthn/browser',
-    )
-  }
-}
-
-interface PasskeyLoginResponse {
-  access_token: string
-  token_type: string
-  expires_in: number
-}
-
-/** Registers and authenticates passkeys using WebAuthn, lazily loading the browser dependency. */
-export function usePasskey() {
-  const authStore = useAuthStore()
-  const settingsStore = useSettingsStore()
-
-  function getApiBaseUrl(): string {
-    return settingsStore.getApiBaseUrl()
-  }
-
-  async function isSupported(): Promise<boolean> {
-    try {
-      const { browserSupportsWebAuthn } = await loadWebAuthn()
-      return browserSupportsWebAuthn()
-    } catch {
-      return false
-    }
-  }
-
-  async function registerPasskey(deviceName?: string): Promise<boolean> {
-    const webauthn = await loadWebAuthn()
-    if (!webauthn.browserSupportsWebAuthn()) {
-      authStore.setError('WebAuthn is not supported in this browser')
-      return false
-    }
-
-    authStore.setLoading(true)
-    authStore.setError(null)
-
-    try {
-      const optionsResponse = await axios.get<{ options: string }>(
-        `${getApiBaseUrl()}/auth/passkey/register/options`,
-        {
-          headers: { Authorization: `Bearer ${authStore.token}` },
-          withCredentials: true,
-        }
-      )
-
-      const options = JSON.parse(optionsResponse.data.options)
-
-      const credential = await webauthn.startRegistration(options)
-
-      await axios.post(
-        `${getApiBaseUrl()}/auth/passkey/register/verify`,
-        {
-          credential: JSON.stringify(credential),
-          device_name: deviceName,
-        },
-        {
-          headers: { Authorization: `Bearer ${authStore.token}` },
-          withCredentials: true,
-        }
-      )
-
-      authStore.setAuthConfig({
-        ...authStore.authConfig,
-        passkeyRegistered: true,
-      })
-
-      return true
-    } catch (error) {
-      if (axios.isAxiosError(error) && error.response) {
-        authStore.setError(error.response.data.detail || 'Passkey registration failed')
-      } else if (error instanceof Error) {
-        if (error.name === 'NotAllowedError') {
-          authStore.setError('Registration was cancelled or timed out')
-        } else if (error.name === 'InvalidStateError') {
-          authStore.setError('This authenticator is already registered')
-        } else {
-          authStore.setError(error.message)
-        }
-      } else {
-        authStore.setError('Passkey registration failed')
-      }
-      return false
-    } finally {
-      authStore.setLoading(false)
-    }
-  }
-
-  async function loginWithPasskey(): Promise<boolean> {
-    const webauthn = await loadWebAuthn()
-    if (!webauthn.browserSupportsWebAuthn()) {
-      authStore.setError('WebAuthn is not supported in this browser')
-      return false
-    }
-
-    authStore.setLoading(true)
-    authStore.setError(null)
-
-    try {
-      const optionsResponse = await axios.get<{ options: string }>(
-        `${getApiBaseUrl()}/auth/passkey/login/options`,
-        { withCredentials: true }
-      )
-
-      const options = JSON.parse(optionsResponse.data.options)
-
-      const credential = await webauthn.startAuthentication(options)
-
-      const response = await axios.post<PasskeyLoginResponse>(
-        `${getApiBaseUrl()}/auth/passkey/login/verify`,
-        { credential: JSON.stringify(credential) },
-        { withCredentials: true }
-      )
-
-      authStore.setToken(response.data.access_token, response.data.expires_in)
-
-      return true
-    } catch (error) {
-      if (axios.isAxiosError(error) && error.response) {
-        if (error.response.status === 404) {
-          authStore.setError('No passkeys registered. Please login with password first.')
-        } else {
-          authStore.setError(error.response.data.detail || 'Passkey login failed')
-        }
-      } else if (error instanceof Error) {
-        if (error.name === 'NotAllowedError') {
-          authStore.setError('Authentication was cancelled or timed out')
-        } else {
-          authStore.setError(error.message)
-        }
-      } else {
-        authStore.setError('Passkey login failed')
-      }
-      return false
-    } finally {
-      authStore.setLoading(false)
-    }
-  }
-
-  async function listCredentials(): Promise<CredentialInfo[]> {
-    try {
-      const response = await axios.get<{ credentials: CredentialInfo[] }>(
-        `${getApiBaseUrl()}/auth/passkey/credentials`,
-        {
-          headers: { Authorization: `Bearer ${authStore.token}` },
-        }
-      )
-      return response.data.credentials
-    } catch {
-      return []
-    }
-  }
-
-  async function deleteCredential(credentialId: string): Promise<boolean> {
-    try {
-      await axios.delete(
-        `${getApiBaseUrl()}/auth/passkey/credentials/${encodeURIComponent(credentialId)}`,
-        {
-          headers: { Authorization: `Bearer ${authStore.token}` },
-        }
-      )
-
-      const remaining = await listCredentials()
-      if (remaining.length === 0) {
-        authStore.setAuthConfig({
-          ...authStore.authConfig,
-          passkeyRegistered: false,
-        })
-      }
-
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  async function deleteAllCredentials(): Promise<boolean> {
-    try {
-      await axios.delete(`${getApiBaseUrl()}/auth/passkey/credentials`, {
-        headers: { Authorization: `Bearer ${authStore.token}` },
-      })
-
-      authStore.setAuthConfig({
-        ...authStore.authConfig,
-        passkeyRegistered: false,
-      })
-
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  return {
-    isSupported,
-    registerPasskey,
-    loginWithPasskey,
-    listCredentials,
-    deleteCredential,
-    deleteAllCredentials,
-  }
-}

package/src/composables/usePluginConfig.ts

@@ -1,252 +0,0 @@
-import { ref, computed, onMounted, type Ref, type ComputedRef } from 'vue'
-import { useApi } from './useApi'
-import { usePlatformContext } from './usePlatformContext'
-import { getInjectedPlatformContext } from './platformContextHelpers'
-import { useRequestSyncState } from './useRequestSyncState'
-
-const PLATFORM_OWNED_SETTINGS_KEY = 'allowed_experiment_types'
-
-function cloneConfig(config: Record<string, unknown>): Record<string, unknown> {
-  return JSON.parse(JSON.stringify(config)) as Record<string, unknown>
-}
-
-function hasOwnConfig(config: Record<string, unknown>, key: string): boolean {
-  return Object.prototype.hasOwnProperty.call(config, key)
-}
-
-function changedTopLevelKeys(
-  current: Record<string, unknown>,
-  saved: Record<string, unknown>,
-): Set<string> {
-  return new Set(
-    [...new Set([...Object.keys(current), ...Object.keys(saved)])].filter(
-      key => JSON.stringify(current[key]) !== JSON.stringify(saved[key]),
-    ),
-  )
-}
-
-function topLevelConfigPatch(
-  current: Record<string, unknown>,
-  keys: Iterable<string>,
-): Record<string, unknown> {
-  return Object.fromEntries(
-    [...keys].map(key => [
-      key,
-      hasOwnConfig(current, key) ? current[key] : null,
-    ]),
-  )
-}
-
-function platformOwnedConfigPatch(config: Record<string, unknown>): Record<string, unknown> {
-  return {
-    [PLATFORM_OWNED_SETTINGS_KEY]: hasOwnConfig(config, PLATFORM_OWNED_SETTINGS_KEY)
-      ? config[PLATFORM_OWNED_SETTINGS_KEY]
-      : null,
-  }
-}
-
-function responseConfigPayload(response: {
-  config?: Record<string, unknown>
-  settings?: Record<string, unknown>
-}): Record<string, unknown> {
-  return response.config ?? response.settings ?? {}
-}
-
-export interface UsePluginConfigReturn {
-  /** Editable plugin configuration values. */
-  config: Ref<Record<string, unknown>>
-  /** Whether the config is currently loading. */
-  isLoading: Ref<boolean>
-  /** Whether the config is currently saving. */
-  isSaving: Ref<boolean>
-  /** Error message from the last failed operation, or null. */
-  error: Ref<string | null>
-  /** Timestamp of the last successful load, or null. */
-  lastLoadedAt: Ref<Date | null>
-  /** Timestamp of the last successful save, or null. */
-  lastSavedAt: Ref<Date | null>
-  /** Whether local config differs from the last loaded or saved snapshot. */
-  isDirty: ComputedRef<boolean>
-  /** Load plugin configuration from the platform. */
-  load: () => Promise<void>
-  /** Save plugin configuration to the platform. */
-  save: () => Promise<boolean>
-  /** Restore the last loaded or saved configuration snapshot. */
-  reset: () => void
-}
-
-/**
- * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `usePluginSettings()` for typed plugin settings.
- */
-export function usePluginConfig(pluginName?: string): UsePluginConfigReturn {
-  const injectedContext = getInjectedPlatformContext()
-  const { plugin } = usePlatformContext()
-  const platformApi = useApi()
-  const pluginApi = useApi({
-    baseUrl: injectedContext?.plugin?.api_prefix ?? plugin.value?.api_prefix,
-  })
-
-  const resolvedName = computed(
-    () => pluginName ?? plugin.value?.name ?? injectedContext?.plugin?.name ?? '',
-  )
-  const usesPluginSettingsApi = computed(() => {
-    const currentPlugin = injectedContext?.plugin ?? plugin.value
-    return currentPlugin?.settings_api === 'plugin'
-      && resolvedName.value === currentPlugin.name
-  })
-
-  const config = ref<Record<string, unknown>>({})
-  const savedConfig = ref<Record<string, unknown>>({})
-  const revision = ref<string | null>(null)
-  const request = useRequestSyncState('Plugin config request failed.')
-  const isLoading = ref(false)
-  const isSaving = ref(false)
-  const error = request.error
-  const lastLoadedAt = request.lastLoadedAt
-  const lastSavedAt = request.lastSavedAt
-
-  const isDirty = computed(() => {
-    return JSON.stringify(config.value) !== JSON.stringify(savedConfig.value)
-  })
-
-  async function load(): Promise<void> {
-    const name = resolvedName.value
-    if (!name) return
-
-    isLoading.value = true
-    try {
-      const response = usesPluginSettingsApi.value
-        ? await request.run(
-          () => pluginApi.get<{
-            settings: Record<string, unknown>
-            mode?: string
-            revision?: string
-          }>('/settings'),
-          { success: 'load', errorMessage: 'Failed to load plugin config' },
-        )
-        : await request.run(
-          () => platformApi.get<{
-            plugin_name: string
-            config: Record<string, unknown>
-            revision?: string
-          }>(
-            `/plugins/${encodeURIComponent(name)}/config`,
-          ),
-          { success: 'load', errorMessage: 'Failed to load plugin config' },
-        )
-      const responseConfig = responseConfigPayload(response)
-      config.value = cloneConfig(responseConfig)
-      savedConfig.value = cloneConfig(responseConfig)
-      revision.value = response.revision ?? null
-    } catch {
-      // Error state is handled by request.run().
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  async function save(): Promise<boolean> {
-    const name = resolvedName.value
-    if (!name) return false
-
-    isSaving.value = true
-    try {
-      const payload = cloneConfig(config.value)
-      let response: {
-        plugin_name?: string
-        config?: Record<string, unknown>
-        settings?: Record<string, unknown>
-        mode?: string
-        revision?: string
-      } | undefined
-      let nextRevision = revision.value
-
-      if (usesPluginSettingsApi.value) {
-        response = await request.run(
-          () => pluginApi.put<{
-            settings: Record<string, unknown>
-            mode?: string
-            revision?: string
-          }>(
-            '/settings',
-            payload,
-            revision.value
-              ? { headers: { 'If-Match': `"${revision.value}"` } }
-              : undefined,
-          ),
-          { success: 'save', errorMessage: 'Failed to save plugin config' },
-        )
-        nextRevision = response.revision ?? nextRevision
-      } else {
-        const dirtyKeys = changedTopLevelKeys(payload, savedConfig.value)
-        const platformOwnedChanged = dirtyKeys.has(PLATFORM_OWNED_SETTINGS_KEY)
-        const typedKeys = [...dirtyKeys].filter(
-          key => key !== PLATFORM_OWNED_SETTINGS_KEY,
-        )
-
-        if (typedKeys.length) {
-          response = await request.run(
-            () => platformApi.patch<{
-              plugin_name: string
-              config: Record<string, unknown>
-              revision?: string
-            }>(
-              `/plugins/${encodeURIComponent(name)}/config`,
-              { config: topLevelConfigPatch(payload, typedKeys) },
-            ),
-            { success: 'save', errorMessage: 'Failed to save plugin config' },
-          )
-          nextRevision = response.revision ?? nextRevision
-        }
-
-        if (platformOwnedChanged) {
-          response = await request.run(
-            () => platformApi.patch<{
-              plugin_name: string
-              config: Record<string, unknown>
-              revision?: string
-            }>(
-              `/plugins/${encodeURIComponent(name)}/config`,
-              { config: platformOwnedConfigPatch(payload) },
-            ),
-            { success: 'save', errorMessage: 'Failed to save plugin config' },
-          )
-          nextRevision = response.revision ?? nextRevision
-        }
-      }
-
-      if (!response) return true
-      const responseConfig = responseConfigPayload(response)
-      config.value = cloneConfig(responseConfig)
-      savedConfig.value = cloneConfig(responseConfig)
-      revision.value = response.revision ?? nextRevision
-      return true
-    } catch {
-      return false
-    } finally {
-      isSaving.value = false
-    }
-  }
-
-  function reset(): void {
-    config.value = cloneConfig(savedConfig.value)
-    request.clearError()
-  }
-
-  onMounted(() => {
-    load()
-  })
-
-  return {
-    config,
-    isLoading,
-    isSaving,
-    error,
-    lastLoadedAt,
-    lastSavedAt,
-    isDirty,
-    load,
-    save,
-    reset,
-  }
-}

package/src/composables/useResourceCrud.ts

@@ -1,235 +0,0 @@
-import { computed, ref, shallowRef, type ComputedRef, type Ref, type ShallowRef } from 'vue'
-import { readErrorMessage } from '../utils/errors'
-
-export type ResourceKey = string | number
-
-export interface ResourceCrudAdapter<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
-  list: () => Promise<TItem[]>
-  create?: (payload: TCreate) => Promise<TItem>
-  update?: (key: TKey, payload: TUpdate) => Promise<TItem>
-  remove?: (key: TKey) => Promise<void>
-}
-
-export interface UseResourceCrudOptions<
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
-> {
-  adapter: ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>
-  initialItems?: readonly TItem[]
-  getKey?: (item: TItem) => TKey
-  readErrorMessage?: (error: unknown) => string
-}
-
-export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends ResourceKey> {
-  items: Ref<TItem[]>
-  loading: ShallowRef<boolean>
-  saving: ShallowRef<boolean>
-  deleting: ShallowRef<boolean>
-  error: Ref<string | null>
-  isBusy: ComputedRef<boolean>
-  load: () => Promise<TItem[]>
-  createItem: (payload: TCreate) => Promise<TItem>
-  updateItem: (key: TKey, payload: TUpdate) => Promise<TItem>
-  deleteItem: (keyOrItem: TKey | TItem) => Promise<void>
-  setItems: (items: readonly TItem[]) => void
-  upsertLocal: (item: TItem) => void
-  removeLocal: (keyOrItem: TKey | TItem) => void
-  clearError: () => void
-}
-
-/**
- * Common list/create/update/delete state wrapper for generated plugin clients.
- *
- * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useGeneratedPluginClient()` instead.
- */
-export function useResourceCrud<
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
->(
-  options: UseResourceCrudOptions<TItem, TCreate, TUpdate, TKey>,
-): UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey> {
-  const items = ref<TItem[]>([...(options.initialItems ?? [])]) as Ref<TItem[]>
-  const loading = shallowRef(false)
-  const saving = shallowRef(false)
-  const deleting = shallowRef(false)
-  const error = ref<string | null>(null)
-  const isBusy = computed(() => loading.value || saving.value || deleting.value)
-
-  const readMessage = options.readErrorMessage ?? readErrorMessage
-  const getKey = options.getKey ?? defaultGetKey<TKey, TItem>
-
-  function clearError(): void {
-    error.value = null
-  }
-
-  function setError(err: unknown): void {
-    error.value = readMessage(err)
-  }
-
-  function setItems(nextItems: readonly TItem[]): void {
-    items.value = [...nextItems]
-  }
-
-  function upsertLocal(item: TItem): void {
-    const key = getKey(item)
-    const index = items.value.findIndex(existing => getKey(existing) === key)
-    if (index === -1) {
-      items.value = [...items.value, item]
-      return
-    }
-    items.value = [
-      ...items.value.slice(0, index),
-      item,
-      ...items.value.slice(index + 1),
-    ]
-  }
-
-  function removeLocal(keyOrItem: TKey | TItem): void {
-    const key = resolveKey(keyOrItem, getKey)
-    items.value = items.value.filter(item => getKey(item) !== key)
-  }
-
-  async function load(): Promise<TItem[]> {
-    loading.value = true
-    clearError()
-    try {
-      const result = await options.adapter.list()
-      setItems(result)
-      return result
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      loading.value = false
-    }
-  }
-
-  async function createItem(payload: TCreate): Promise<TItem> {
-    if (!options.adapter.create) {
-      throw new Error('[MINT SDK] Resource adapter does not implement create().')
-    }
-    saving.value = true
-    clearError()
-    try {
-      const result = await options.adapter.create(payload)
-      upsertLocal(result)
-      return result
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      saving.value = false
-    }
-  }
-
-  async function updateItem(key: TKey, payload: TUpdate): Promise<TItem> {
-    if (!options.adapter.update) {
-      throw new Error('[MINT SDK] Resource adapter does not implement update().')
-    }
-    saving.value = true
-    clearError()
-    try {
-      const result = await options.adapter.update(key, payload)
-      upsertLocal(result)
-      return result
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      saving.value = false
-    }
-  }
-
-  async function deleteItem(keyOrItem: TKey | TItem): Promise<void> {
-    if (!options.adapter.remove) {
-      throw new Error('[MINT SDK] Resource adapter does not implement remove().')
-    }
-    const key = resolveKey(keyOrItem, getKey)
-    deleting.value = true
-    clearError()
-    try {
-      await options.adapter.remove(key)
-      removeLocal(key)
-    } catch (err) {
-      setError(err)
-      throw err
-    } finally {
-      deleting.value = false
-    }
-  }
-
-  return {
-    items,
-    loading,
-    saving,
-    deleting,
-    error,
-    isBusy,
-    load,
-    createItem,
-    updateItem,
-    deleteItem,
-    setItems,
-    upsertLocal,
-    removeLocal,
-    clearError,
-  }
-}
-
-export interface PluginResourceClientOptions<
-  TClient,
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
-> {
-  client: TClient
-  list: (client: TClient) => Promise<TItem[]>
-  create?: (client: TClient, payload: TCreate) => Promise<TItem>
-  update?: (client: TClient, key: TKey, payload: TUpdate) => Promise<TItem>
-  remove?: (client: TClient, key: TKey) => Promise<void>
-}
-
-export function createPluginResourceClient<
-  TClient,
-  TItem,
-  TCreate = Partial<TItem>,
-  TUpdate = Partial<TItem>,
-  TKey extends ResourceKey = ResourceKey,
->(
-  options: PluginResourceClientOptions<TClient, TItem, TCreate, TUpdate, TKey>,
-): ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey> {
-  return {
-    list: () => options.list(options.client),
-    create: options.create
-      ? payload => options.create!(options.client, payload)
-      : undefined,
-    update: options.update
-      ? (key, payload) => options.update!(options.client, key, payload)
-      : undefined,
-    remove: options.remove
-      ? key => options.remove!(options.client, key)
-      : undefined,
-  }
-}
-
-function defaultGetKey<TKey extends ResourceKey, TItem>(item: TItem): TKey {
-  if (item && typeof item === 'object' && 'id' in item) {
-    return (item as { id: ResourceKey }).id as TKey
-  }
-  throw new Error('[MINT SDK] Resource items need an id field or a getKey option.')
-}
-
-function resolveKey<TItem, TKey extends ResourceKey>(
-  keyOrItem: TKey | TItem,
-  getKey: (item: TItem) => TKey,
-): TKey {
-  if (typeof keyOrItem === 'string' || typeof keyOrItem === 'number') {
-    return keyOrItem as TKey
-  }
-  return getKey(keyOrItem as TItem)
-}