@morscherlab/mint-sdk 1.1.25 → 1.2.0-beta.2

package/src/composables/usePluginClient.ts

@@ -1,8 +1,6 @@
 import {
   computed,
-  getCurrentInstance,
   onMounted,
-  onUnmounted,
   ref,
   shallowRef,
   watch,
@@ -28,6 +26,12 @@ import {
   pluginEndpointRequestParts,
   requestBodyFromPayload,
 } from './pluginEndpointBuilder'
+import {
+  useEventStream,
+  type EventStreamMessage,
+  type EventStreamTransport,
+  type UseEventStreamReturn,
+} from './useEventStream'
 import type {
   ExperimentSummary,
   GeneratedJobDefinition,
@@ -204,13 +208,7 @@ export interface UsePluginSettingsReturn<TSettings = Record<string, unknown>> {
   reset: () => void
 }
 
-export interface PluginEventStreamMessage<TData = string> {
-  event: string
-  data: TData
-  id?: string
-  retry?: number
-  raw: string
-}
+export type PluginEventStreamMessage<TData = string> = EventStreamMessage<TData>
 
 export interface PluginEventStreamOptions<TData = string> {
   /** Override the generated or platform-injected API base URL. */
@@ -232,15 +230,7 @@ export interface PluginEventStreamOptions<TData = string> {
   onError?: (error: unknown) => void
 }
 
-export interface UsePluginEventStreamReturn<TData = string> {
-  isConnected: Ref<boolean>
-  isConnecting: Ref<boolean>
-  error: Ref<string | null>
-  lastMessage: Ref<PluginEventStreamMessage<TData> | null>
-  lastEventId: Ref<string | null>
-  start: () => void
-  stop: () => void
-}
+export type UsePluginEventStreamReturn<TData = string> = UseEventStreamReturn<TData>
 
 export type PluginFormDataValue =
   | string
@@ -544,11 +534,6 @@ export async function downloadPluginEndpoint(
   return blob
 }
 
-/** Return a generated plugin client from setup code with a stable typed identity. */
-export function usePluginClient<TClient>(client: TClient): TClient {
-  return client
-}
-
 function normalizePluginSettingsOptions(options: UsePluginSettingsOptions | string = {}): UsePluginSettingsOptions {
   return typeof options === 'string' ? { pluginName: options } : options
 }
@@ -797,13 +782,13 @@ export function usePluginSettings<TSettings = Record<string, unknown>>(
 }
 
 function streamRequestAuth(
-  options: PluginEventStreamOptions<unknown>,
+  requestHeaders: HeadersInit | undefined,
   policy: { requiresAuth: boolean },
 ): {
   headers: Headers
   token?: string
 } {
-  const headers = new Headers(options.headers)
+  const headers = new Headers(requestHeaders)
   const authStore = useAuthStore()
   if (!authStore.isInitialized) {
     authStore.initialize()
@@ -811,7 +796,6 @@ function streamRequestAuth(
   if (policy.requiresAuth && authStore.token && !headers.has('Authorization')) {
     headers.set('Authorization', `Bearer ${authStore.token}`)
   }
-  headers.set('Accept', 'text/event-stream')
   const token = policy.requiresAuth ? authStore.token : undefined
   return {
     headers,
@@ -819,40 +803,22 @@ function streamRequestAuth(
   }
 }
 
-function parseSseEvent<TData>(
-  block: string,
-  parseJson: boolean,
-): PluginEventStreamMessage<TData> | null {
-  let event = 'message'
-  let id: string | undefined
-  let retry: number | undefined
-  const dataLines: string[] = []
-
-  for (const line of block.split(/\r?\n/)) {
-    if (!line || line.startsWith(':')) continue
-    const separator = line.indexOf(':')
-    const field = separator === -1 ? line : line.slice(0, separator)
-    const value = separator === -1
-      ? ''
-      : line.slice(separator + 1).replace(/^ /, '')
-
-    if (field === 'event') event = value || 'message'
-    if (field === 'data') dataLines.push(value)
-    if (field === 'id') id = value
-    if (field === 'retry') {
-      const parsed = Number(value)
-      if (Number.isFinite(parsed)) retry = parsed
+function pluginEventStreamTransport(
+  endpoint: PluginEndpointDefinition,
+): EventStreamTransport {
+  return async (url, init = {}) => {
+    if (typeof fetch !== 'function') {
+      throw new Error('[MINT SDK] fetch is required for plugin event streams.')
     }
-  }
-
-  if (!dataLines.length && !id && retry === undefined) return null
-  const data = dataLines.join('\n')
-  return {
-    event,
-    data: (parseJson && data ? JSON.parse(data) : data) as TData,
-    id,
-    retry,
-    raw: block,
+    const requestAuth = streamRequestAuth(
+      init.headers,
+      { requiresAuth: endpoint.requiresAuth !== false },
+    )
+    const response = await fetch(url, { ...init, headers: requestAuth.headers })
+    if (response.status === 401) {
+      throw authenticationRequiredError(response, requestAuth.token)
+    }
+    return response
   }
 }
 
@@ -891,6 +857,9 @@ export function usePluginEventStream<TData = string>(
   payloadOrOptions?: unknown,
   maybeOptions?: PluginEventStreamOptions<TData>,
 ): UsePluginEventStreamReturn<TData> {
+  if (endpoint.method !== 'get') {
+    throw new Error(`[MINT SDK] Plugin event streams must use GET; got ${endpoint.method}`)
+  }
   const payload = maybeOptions === undefined && looksLikeEventStreamOptions(payloadOrOptions)
     ? undefined
     : payloadOrOptions
@@ -899,198 +868,25 @@ export function usePluginEventStream<TData = string>(
       ? payloadOrOptions
       : maybeOptions ?? {}
   ) as PluginEventStreamOptions<TData>
-  const isConnected = ref(false)
-  const isConnecting = ref(false)
-  const error = ref<string | null>(null)
-  const lastMessage = shallowRef<PluginEventStreamMessage<TData> | null>(null)
-  const lastEventId = ref<string | null>(null)
   const responseType = endpoint.responseType?.trim()
   const parseJson = options.parseJson ?? Boolean(responseType && responseType !== 'string')
-  let controller: AbortController | null = null
-  let reconnectTimer: ReturnType<typeof setTimeout> | null = null
-  let stopped = true
-  let generation = 0
-
-  function clearReconnectTimer(): void {
-    if (reconnectTimer !== null) {
-      clearTimeout(reconnectTimer)
-      reconnectTimer = null
-    }
-  }
-
-  function ownsConnection(
-    connectionGeneration: number,
-    connectionController: AbortController,
-  ): boolean {
-    return !stopped
-      && generation === connectionGeneration
-      && controller === connectionController
-  }
-
-  function scheduleReconnect(connectionGeneration: number): void {
-    if (
-      stopped
-      || generation !== connectionGeneration
-      || options.reconnect === false
-    ) return
-    clearReconnectTimer()
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null
-      if (stopped || generation !== connectionGeneration) return
-      void connect(connectionGeneration)
-    }, options.reconnectDelayMs ?? 2000)
-  }
-
-  async function connect(connectionGeneration: number): Promise<void> {
-    if (stopped || generation !== connectionGeneration) return
-    if (endpoint.method !== 'get') {
-      throw new Error(`[MINT SDK] Plugin event streams must use GET; got ${endpoint.method}`)
-    }
-    if (typeof fetch !== 'function') {
-      throw new Error('[MINT SDK] fetch is required for plugin event streams.')
-    }
-
-    controller?.abort()
-    const connectionController = new AbortController()
-    controller = connectionController
-    isConnecting.value = true
-    if (!ownsConnection(connectionGeneration, connectionController)) return
-    error.value = null
-    if (!ownsConnection(connectionGeneration, connectionController)) return
-
-    let authenticationFailed = false
-    try {
-      const url = buildPluginEndpointUrl(contract, endpoint, payload, {
-        baseUrl: options.baseUrl,
-      })
-      const requestAuth = streamRequestAuth(
-        options as PluginEventStreamOptions<unknown>,
-        { requiresAuth: endpoint.requiresAuth !== false },
-      )
-      const response = await fetch(url, {
-        method: 'GET',
-        headers: requestAuth.headers,
-        credentials: options.credentials ?? 'same-origin',
-        signal: connectionController.signal,
-      })
-
-      if (!ownsConnection(connectionGeneration, connectionController)) return
-
-      if (!response.ok) {
-        if (response.status === 401) {
-          authenticationFailed = true
-          throw authenticationRequiredError(response, requestAuth.token)
-        }
-        throw new Error(`Plugin event stream failed with HTTP ${response.status}`)
-      }
-      if (!response.body) {
-        throw new Error('Plugin event stream response did not include a readable body.')
-      }
-
-      isConnected.value = true
-      if (!ownsConnection(connectionGeneration, connectionController)) return
-      options.onOpen?.()
-      if (!ownsConnection(connectionGeneration, connectionController)) return
-      const reader = response.body.getReader()
-      const decoder = new TextDecoder()
-      let buffer = ''
-
-      for (;;) {
-        const { value, done } = await reader.read()
-        if (!ownsConnection(connectionGeneration, connectionController)) return
-        if (done) break
-        buffer += decoder.decode(value, { stream: true })
-
-        let boundary = buffer.search(/\r?\n\r?\n/)
-        while (boundary !== -1) {
-          const block = buffer.slice(0, boundary)
-          buffer = buffer.slice(buffer[boundary] === '\r' ? boundary + 4 : boundary + 2)
-          const message = parseSseEvent<TData>(block, parseJson)
-          if (message) {
-            lastMessage.value = message
-            if (!ownsConnection(connectionGeneration, connectionController)) return
-            if (message.id !== undefined) {
-              lastEventId.value = message.id
-              if (!ownsConnection(connectionGeneration, connectionController)) return
-            }
-            if (message.retry !== undefined) {
-              options.reconnectDelayMs = message.retry
-            }
-            if (!ownsConnection(connectionGeneration, connectionController)) return
-            options.onMessage?.(message)
-            if (!ownsConnection(connectionGeneration, connectionController)) return
-          }
-          boundary = buffer.search(/\r?\n\r?\n/)
-        }
-      }
-    } catch (err) {
-      if (err instanceof AuthenticationRequiredError) authenticationFailed = true
-      if (
-        ownsConnection(connectionGeneration, connectionController)
-        && !(err instanceof DOMException && err.name === 'AbortError')
-      ) {
-        const message = err instanceof Error ? err.message : 'Plugin event stream failed'
-        error.value = message
-        if (ownsConnection(connectionGeneration, connectionController)) {
-          options.onError?.(err)
-        }
-      }
-    } finally {
-      if (ownsConnection(connectionGeneration, connectionController)) {
-        isConnecting.value = false
-        if (ownsConnection(connectionGeneration, connectionController)) {
-          isConnected.value = false
-          if (ownsConnection(connectionGeneration, connectionController)) {
-            controller = null
-            if (authenticationFailed) {
-              stopped = true
-            } else {
-              scheduleReconnect(connectionGeneration)
-            }
-          }
-        }
-      }
-    }
-  }
-
-  function start(): void {
-    if (!stopped) return
-    stopped = false
-    clearReconnectTimer()
-    generation += 1
-    void connect(generation)
-  }
-
-  function stop(): void {
-    if (stopped) return
-    stopped = true
-    generation += 1
-    clearReconnectTimer()
-    controller?.abort()
-    controller = null
-    isConnecting.value = false
-    isConnected.value = false
-  }
-
-  const currentInstance = getCurrentInstance()
-  if (currentInstance && options.immediate !== false && typeof window === 'undefined') {
-    onMounted(start)
-  }
-  if (currentInstance) onUnmounted(stop)
-
-  if (options.immediate !== false && (typeof window !== 'undefined' || !currentInstance)) {
-    start()
-  }
-
-  return {
-    isConnected,
-    isConnecting,
-    error,
-    lastMessage,
-    lastEventId,
-    start,
-    stop,
-  }
+  return useEventStream<TData>(
+    () => buildPluginEndpointUrl(contract, endpoint, payload, { baseUrl: options.baseUrl }),
+    {
+      transport: pluginEventStreamTransport(endpoint),
+      immediate: options.immediate,
+      reconnect: options.reconnect,
+      reconnectDelayMs: options.reconnectDelayMs,
+      parseJson,
+      credentials: options.credentials,
+      headers: options.headers,
+      shouldReconnect: cause => !(cause instanceof AuthenticationRequiredError),
+      onOpen: options.onOpen,
+      onMessage: options.onMessage,
+      onError: options.onError,
+      errorLabel: 'Plugin event stream',
+    },
+  )
 }
 
 /** Read and optionally load the current platform experiment for integrated plugin views. */

package/src/stores/auth.ts

@@ -58,7 +58,6 @@ export const useAuthStore = defineStore('mint-auth', () => {
     passkeyEnabled: false,
     passkeyRegistered: false,
     registrationEnabled: false,
-    databaseMode: 'none',
     experimentVisibilityMode: 'open',
   })
   const isInitialized = ref(false)

package/src/types/auth.ts

@@ -6,7 +6,6 @@ export interface AuthConfig {
   passkeyEnabled: boolean
   passkeyRegistered: boolean
   registrationEnabled: boolean
-  databaseMode: string
   experimentVisibilityMode?: 'open' | 'restricted'
 }
 

package/dist/__tests__/composables/usePluginConfig.test.d.ts

@@ -1,15 +0,0 @@
-/**
- * Tests for usePluginConfig.
- *
- * Covers the plugin settings life-cycle used by every plugin's
- * settings pane:
- *
- * - resolvedName prefers explicit pluginName, falls back to platform plugin
- * - load() populates config + savedConfig from /plugins/{name}/config
- * - save() PATCHes the endpoint, updates savedConfig, returns true
- * - isDirty reflects user edits vs last saved state
- * - reset() restores config to savedConfig and clears error
- * - lastLoadedAt / lastSavedAt track successful syncs
- * - error messages bubble up from network failures
- */
-export {};