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

package/src/__tests__/composables/usePluginClient.test.ts

@@ -14,7 +14,6 @@ import {
   uploadPluginEndpoint,
   useCurrentExperiment,
   usePluginEventStream,
-  usePluginClient,
   usePluginSettings,
   type PluginContract,
 } from '../../composables/usePluginClient'
@@ -80,7 +79,13 @@ function pendingEventStreamResponse(): {
   })
   return {
     response: new Response(body, { status: 200 }),
-    close: () => streamController.close(),
+    close: () => {
+      try {
+        streamController.close()
+      } catch {
+        // stop() may already have cancelled the reader.
+      }
+    },
   }
 }
 
@@ -1396,11 +1401,7 @@ describe('usePluginClient', () => {
 
     try {
       stream.start()
-      await Promise.resolve()
-      await Promise.resolve()
-      await Promise.resolve()
-
-      expect(onOpen).toHaveBeenCalledOnce()
+      await vi.waitFor(() => expect(onOpen).toHaveBeenCalledOnce())
     } finally {
       stopWatching()
       stream.stop()
@@ -1684,12 +1685,6 @@ describe('usePluginClient', () => {
     expect(requestConfigs).toHaveLength(0)
   })
 
-  it('returns the provided client identity from usePluginClient', () => {
-    const client = createPluginClient(contract, { endpoints: {} })
-
-    expect(usePluginClient(client)).toBe(client)
-  })
-
   it('loads the current experiment from URL conventions', async () => {
     window.history.replaceState({}, '', '/analysis?experimentId=42')
     const current = useCurrentExperiment<{ called: string }>({ immediate: false })

package/src/__tests__/docs/frontendDocsCatalog.test.ts

@@ -271,6 +271,18 @@ describe('frontend docs catalog coverage', () => {
     })
   })
 
+  it('documents only the source-driven JobsStatusTray props', () => {
+    const manifest = extractFrontendManifest()
+    const jobsStatusTray = manifest.categories.components.find(item => item.name === 'JobsStatusTray')
+
+    expect(jobsStatusTray?.props?.map(prop => prop.name).sort()).toEqual([
+      'loadOnMount',
+      'source',
+      'teleportTo',
+      'title',
+    ])
+  })
+
   it('re-exports every public component from the root SDK entrypoint', () => {
     const publicComponents = parseComponentExports()
     const rootComponents = parseRootComponentExports()
@@ -295,6 +307,7 @@ describe('frontend docs catalog coverage', () => {
     const rootIndex = readFileSync(join(SDK_ROOT, 'src', 'index.ts'), 'utf8')
     const componentsIndex = readFileSync(join(SDK_ROOT, 'src', 'components', 'index.ts'), 'utf8')
     const composablesIndex = readFileSync(join(SDK_ROOT, 'src', 'composables', 'index.ts'), 'utf8')
+    const composableExports = composablesIndex.replace(/from\s+['"][^'"]+['"]/g, '')
 
     const retiredNames = [
       'ToastNotification',
@@ -306,12 +319,20 @@ describe('frontend docs catalog coverage', () => {
       'AppPillNav',
       'usePluginApi',
       'UsePluginApiOptions',
+      'useJobsStatusTray',
+      'UseJobsStatusTrayOptions',
+      'UseJobsStatusTrayReturn',
+      'JobsStatusTrayAdapter',
+      'JobStreamMessage',
+      'usePluginConfig',
+      'UsePluginConfigReturn',
+      'usePluginClient',
     ]
 
     for (const name of retiredNames) {
       expect(rootIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
       expect(componentsIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
-      expect(composablesIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
+      expect(composableExports).not.toMatch(new RegExp(`\\b${name}\\b`))
     }
   })
 

package/src/components/JobsStatusTray.story.vue

@@ -54,10 +54,8 @@ const explicitActionJobs = [
   job('awaiting_input', 'J-201', { can_cancel: true }),
   job('completed', 'J-200', { can_delete: false }),
 ]
-const adapter = {
-  cancelJob: async () => undefined,
-  deleteJob: async () => true,
-}
+const cancelJob = async () => undefined
+const deleteJob = async () => true
 
 function openJob(jobId: string) {
   console.info('open', jobId)
@@ -78,8 +76,7 @@ function initState() {
         <div style="padding: 2rem; min-height: 520px;">
           <JobsStatusTray
             :title="state.title"
-            :jobs="state.jobs"
-            :adapter="adapter"
+            :source="{ jobs: state.jobs, cancelJob, deleteJob }"
             :load-on-mount="false"
             :teleport-to="false"
           >
@@ -99,7 +96,7 @@ function initState() {
     <Variant title="Awaiting input">
       <div style="padding: 2rem; min-height: 520px;">
         <JobsStatusTray
-          :jobs="[job('awaiting_input', 'J-301')]"
+          :source="{ jobs: [job('awaiting_input', 'J-301')] }"
           :load-on-mount="false"
           :teleport-to="false"
         />
@@ -109,8 +106,7 @@ function initState() {
     <Variant title="Explicit actions">
       <div style="padding: 2rem; min-height: 520px;">
         <JobsStatusTray
-          :jobs="explicitActionJobs"
-          :adapter="adapter"
+          :source="{ jobs: explicitActionJobs, cancelJob, deleteJob }"
           :load-on-mount="false"
           :teleport-to="false"
         />
@@ -120,7 +116,7 @@ function initState() {
     <Variant title="Empty">
       <div style="padding: 2rem; min-height: 520px;">
         <JobsStatusTray
-          :jobs="[]"
+          :source="{ jobs: [] }"
           :load-on-mount="false"
           :teleport-to="false"
         />

package/src/components/JobsStatusTray.vue

@@ -15,24 +15,12 @@ import {
 } from '../jobs'
 import {
   usePluginJobCenter,
-  type JobsStatusTrayAdapter,
   type PluginJobCenterSource,
 } from '../composables/useJobsStatusTray'
-import type { UsePluginEventStreamReturn } from '../composables/usePluginClient'
-import type {
-  JobState,
-  JobStateInput,
-  JobStreamData,
-} from '../types/jobs'
+import type { JobState } from '../types/jobs'
 
 interface Props {
   source?: PluginJobCenterSource
-  /** @deprecated Pass a source instead. */
-  jobs?: readonly JobStateInput[]
-  /** @deprecated Pass source actions instead. */
-  adapter?: JobsStatusTrayAdapter
-  /** @deprecated Event streams belong to the source runtime. */
-  eventStream?: UsePluginEventStreamReturn<JobStreamData>
   loadOnMount?: boolean
   title?: string
   teleportTo?: string | HTMLElement | false
@@ -61,9 +49,6 @@ const panelRef = ref<HTMLElement | null>(null)
 const teleportTarget = computed(() => props.teleportTo || 'body')
 const tray = usePluginJobCenter({
   source: toRef(props, 'source'),
-  jobs: toRef(props, 'jobs'),
-  adapter: toRef(props, 'adapter'),
-  eventStream: toRef(props, 'eventStream'),
   loadOnMount: props.loadOnMount,
 })
 const canClear = computed(() => (

package/src/composables/index.ts

@@ -162,7 +162,6 @@ export {
   type DilutionPreset,
   type UseReagentSeriesReturn,
 } from './useReagentSeries'
-export { usePluginConfig, type UsePluginConfigReturn } from './usePluginConfig'
 export {
   useExperimentSelector,
   type UseExperimentSelectorOptions,
@@ -488,7 +487,6 @@ export {
   pluginFormDataFromPayload,
   resolvePluginBaseUrl,
   uploadPluginEndpoint,
-  usePluginClient,
   usePluginEventStream,
   usePluginSettings,
   useCurrentExperiment,
@@ -517,14 +515,9 @@ export {
 export {
   combinePluginJobSources,
   usePluginJobCenter,
-  useJobsStatusTray,
   type CombinedPluginJobCenterSource,
   type PluginJobCenterSource,
-  type JobsStatusTrayAdapter,
   type JobsStatusTrayTab,
-  type JobStreamMessage,
   type UsePluginJobCenterOptions,
   type UsePluginJobCenterReturn,
-  type UseJobsStatusTrayOptions,
-  type UseJobsStatusTrayReturn,
 } from './useJobsStatusTray'

package/src/composables/useAuth.ts

@@ -93,7 +93,6 @@ export function useAuth(): UseAuthReturn {
         passkey_enabled: boolean
         passkey_registered?: boolean
         registration_enabled?: boolean
-        database_mode?: string
         access?: {
           experiment_visibility_mode?: 'open' | 'restricted'
           experimentVisibilityMode?: 'open' | 'restricted'
@@ -105,7 +104,6 @@ export function useAuth(): UseAuthReturn {
         passkeyEnabled: response.data.passkey_enabled,
         passkeyRegistered: response.data.passkey_registered ?? false,
         registrationEnabled: response.data.registration_enabled ?? false,
-        databaseMode: response.data.database_mode ?? 'none',
         experimentVisibilityMode:
           response.data.access?.experiment_visibility_mode
           ?? response.data.access?.experimentVisibilityMode
@@ -121,7 +119,6 @@ export function useAuth(): UseAuthReturn {
         passkeyEnabled: false,
         passkeyRegistered: false,
         registrationEnabled: false,
-        databaseMode: 'none',
         experimentVisibilityMode: 'open',
       }
     }

package/src/composables/useEventStream.ts

@@ -0,0 +1,314 @@
+import {
+  getCurrentInstance,
+  getCurrentScope,
+  onMounted,
+  onScopeDispose,
+  ref,
+  shallowRef,
+  type Ref,
+} from 'vue'
+
+export type EventStreamTransport = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>
+
+export interface EventStreamMessage<TData = string> {
+  event: string
+  data: TData
+  id?: string
+  retry?: number
+  raw: string
+}
+
+export interface EventStreamOptions<TData = string> {
+  transport?: EventStreamTransport
+  headers?: HeadersInit
+  credentials?: RequestCredentials
+  immediate?: boolean
+  reconnect?: boolean
+  reconnectDelayMs?: number
+  parseJson?: boolean
+  shouldReconnect?: (cause?: unknown) => boolean
+  onOpen?: () => void
+  onMessage?: (message: EventStreamMessage<TData>) => void
+  onError?: (cause: unknown) => void
+  onClose?: (cause?: unknown) => void
+  errorLabel?: string
+}
+
+export interface UseEventStreamReturn<TData = string> {
+  isConnected: Ref<boolean>
+  isConnecting: Ref<boolean>
+  error: Ref<string | null>
+  lastMessage: Ref<EventStreamMessage<TData> | null>
+  lastEventId: Ref<string | null>
+  start: () => void
+  stop: () => void
+}
+
+interface ParsedEventStreamBlock<TData> {
+  message?: EventStreamMessage<TData>
+  id?: string
+  retry?: number
+}
+
+class EventStreamResponseError extends Error {
+  constructor(readonly response: Response, label: string) {
+    super(`${label} failed with HTTP ${response.status}`)
+    this.name = 'EventStreamResponseError'
+  }
+}
+
+/** Parse one complete SSE block without owning connection policy. */
+export function parseEventStreamBlock<TData>(
+  block: string,
+  parseJson: boolean,
+): ParsedEventStreamBlock<TData> | null {
+  let event = 'message'
+  let id: string | undefined
+  let retry: number | undefined
+  const dataLines: string[] = []
+
+  for (const line of block.split(/\r\n|\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' && !value.includes('\0')) id = value
+    if (field === 'retry' && /^\d+$/.test(value)) retry = Number(value)
+  }
+
+  if (!dataLines.length && id === undefined && retry === undefined) return null
+  const data = dataLines.join('\n')
+  return {
+    message: dataLines.length
+      ? {
+          event,
+          data: (parseJson && data ? JSON.parse(data) : data) as TData,
+          id,
+          retry,
+          raw: block,
+        }
+      : undefined,
+    id,
+    retry,
+  }
+}
+
+/** Shared fetch-based SSE lifecycle with cancellation and reconnect safety. */
+export function useEventStream<TData = string>(
+  url: string | (() => string),
+  options: EventStreamOptions<TData> = {},
+): UseEventStreamReturn<TData> {
+  const isConnected = ref(false)
+  const isConnecting = ref(false)
+  const error = ref<string | null>(null)
+  const lastMessage = shallowRef<EventStreamMessage<TData> | null>(null)
+  const lastEventId = ref<string | null>(null)
+  let controller: AbortController | null = null
+  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  let reconnectDelayMs = options.reconnectDelayMs ?? 2_000
+  let stopped = true
+  let generation = 0
+
+  function clearReconnectTimer(): void {
+    if (reconnectTimer === null) return
+    clearTimeout(reconnectTimer)
+    reconnectTimer = null
+  }
+
+  function ownsConnection(
+    connectionGeneration: number,
+    connectionController: AbortController,
+  ): boolean {
+    return !stopped
+      && generation === connectionGeneration
+      && controller === connectionController
+  }
+
+  function scheduleReconnect(connectionGeneration: number, cause?: unknown): void {
+    if (stopped || generation !== connectionGeneration) return
+    if (options.reconnect === false || options.shouldReconnect?.(cause) === false) {
+      stopped = true
+      return
+    }
+    clearReconnectTimer()
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null
+      if (stopped || generation !== connectionGeneration) return
+      void connect(connectionGeneration)
+    }, reconnectDelayMs)
+  }
+
+  function dispatchBlock(
+    block: string,
+    connectionGeneration: number,
+    connectionController: AbortController,
+  ): void {
+    const parsed = parseEventStreamBlock<TData>(block, options.parseJson ?? false)
+    if (!parsed || !ownsConnection(connectionGeneration, connectionController)) return
+    if (parsed.id !== undefined) {
+      lastEventId.value = parsed.id
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+    }
+    if (parsed.retry !== undefined) reconnectDelayMs = parsed.retry
+    const message = parsed.message
+    if (!message || !ownsConnection(connectionGeneration, connectionController)) return
+    lastMessage.value = message
+    if (!ownsConnection(connectionGeneration, connectionController)) return
+    options.onMessage?.(message)
+  }
+
+  async function consume(
+    body: ReadableStream<Uint8Array>,
+    connectionGeneration: number,
+    connectionController: AbortController,
+  ): Promise<void> {
+    const connectionReader = body.getReader()
+    reader = connectionReader
+    const decoder = new TextDecoder()
+    let buffer = ''
+    try {
+      for (;;) {
+        const { value, done } = await connectionReader.read()
+        if (!ownsConnection(connectionGeneration, connectionController)) return
+        buffer += decoder.decode(value, { stream: !done })
+
+        let boundary = /(?:\r\n|\r|\n){2}/.exec(buffer)
+        while (boundary?.index !== undefined) {
+          const block = buffer.slice(0, boundary.index)
+          buffer = buffer.slice(boundary.index + boundary[0].length)
+          dispatchBlock(block, connectionGeneration, connectionController)
+          if (!ownsConnection(connectionGeneration, connectionController)) return
+          boundary = /(?:\r\n|\r|\n){2}/.exec(buffer)
+        }
+
+        if (!done) continue
+        if (buffer) dispatchBlock(buffer, connectionGeneration, connectionController)
+        return
+      }
+    } finally {
+      if (reader === connectionReader) reader = null
+      connectionReader.releaseLock()
+    }
+  }
+
+  async function connect(connectionGeneration: number): Promise<void> {
+    if (stopped || generation !== connectionGeneration) return
+    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 cause: unknown
+    try {
+      const headers = new Headers(options.headers)
+      headers.set('Accept', 'text/event-stream')
+      if (lastEventId.value && !headers.has('Last-Event-ID')) {
+        headers.set('Last-Event-ID', lastEventId.value)
+      }
+      const transport = options.transport ?? globalThis.fetch?.bind(globalThis)
+      if (!transport) throw new Error('[MINT SDK] fetch is required for event streams.')
+      const response = await transport(typeof url === 'function' ? url() : url, {
+        method: 'GET',
+        headers,
+        credentials: options.credentials ?? 'same-origin',
+        signal: connectionController.signal,
+      })
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      if (!response.ok) {
+        throw new EventStreamResponseError(response, options.errorLabel ?? 'Event stream')
+      }
+      if (!response.body) {
+        throw new Error(`${options.errorLabel ?? 'Event stream'} response did not include a readable body.`)
+      }
+
+      isConnected.value = true
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      isConnecting.value = false
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      options.onOpen?.()
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      await consume(response.body, connectionGeneration, connectionController)
+    } catch (errorCause) {
+      cause = errorCause
+      if (
+        ownsConnection(connectionGeneration, connectionController)
+        && !isAbortError(errorCause)
+      ) {
+        error.value = errorCause instanceof Error
+          ? errorCause.message
+          : `${options.errorLabel ?? 'Event stream'} failed`
+        if (ownsConnection(connectionGeneration, connectionController)) {
+          options.onError?.(errorCause)
+        }
+      }
+    } finally {
+      if (ownsConnection(connectionGeneration, connectionController)) {
+        isConnecting.value = false
+        if (!ownsConnection(connectionGeneration, connectionController)) return
+        isConnected.value = false
+        if (!ownsConnection(connectionGeneration, connectionController)) return
+        controller = null
+        options.onClose?.(cause)
+        if (!stopped && generation === connectionGeneration) {
+          scheduleReconnect(connectionGeneration, cause)
+        }
+      }
+    }
+  }
+
+  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
+    if (reader) void reader.cancel().catch(() => undefined)
+    reader = null
+    isConnecting.value = false
+    isConnected.value = false
+  }
+
+  const currentInstance = getCurrentInstance()
+  if (currentInstance && options.immediate !== false && typeof window === 'undefined') {
+    onMounted(start)
+  }
+  if (getCurrentScope()) onScopeDispose(stop)
+  if (options.immediate !== false && (typeof window !== 'undefined' || !currentInstance)) {
+    start()
+  }
+
+  return {
+    isConnected,
+    isConnecting,
+    error,
+    lastMessage,
+    lastEventId,
+    start,
+    stop,
+  }
+}
+
+function isAbortError(cause: unknown): boolean {
+  return cause instanceof DOMException && cause.name === 'AbortError'
+}