@morscherlab/mint-sdk 1.1.24 → 1.2.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.1.24",
+  "version": "1.2.0-beta.1",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",

package/src/__tests__/components/GeneratedPluginView.test.ts

@@ -65,7 +65,6 @@ vi.mock('../../composables/useGeneratedAnalysis', async () => {
       loadResult: generated.loadResult,
       resultForJob: generated.resultForJob,
       refreshJobs: vi.fn(),
-      jobsAdapter: {},
       })
     },
   }
@@ -146,8 +145,6 @@ describe('GeneratedPluginView', () => {
       result: wrapper.findComponent(GeneratedResultRenderer).text(),
       jobs: wrapper.findComponent(JobsStatusTray).exists(),
       jobSource: wrapper.findComponent(JobsStatusTray).props('source'),
-      legacyJobs: wrapper.findComponent(JobsStatusTray).props('jobs'),
-      legacyAdapter: wrapper.findComponent(JobsStatusTray).props('adapter'),
     }).toMatchObject({
       workspace: {
         title: 'Demo analysis',
@@ -159,8 +156,6 @@ describe('GeneratedPluginView', () => {
       result: 'complete',
       jobs: true,
       jobSource: expect.any(Object),
-      legacyJobs: undefined,
-      legacyAdapter: undefined,
     })
   })
 

package/src/__tests__/components/JobsStatusTray.test.ts

@@ -1,8 +1,10 @@
 import { mount } from '@vue/test-utils'
 import { describe, expect, it, vi } from 'vitest'
+import { h } from 'vue'
 
 import JobsStatusTray from '../../components/JobsStatusTray.vue'
-import type { JobStateInput, JobStatus } from '../../types/jobs'
+import type { PluginJobCenterSource } from '../../composables/useJobsStatusTray'
+import type { JobState, JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
   return {
@@ -39,16 +41,18 @@ function job(status: JobStatus, id: string = status): JobStateInput {
 }
 
 async function openTray(options: {
-  jobs: JobStateInput[]
-  adapter?: Record<string, unknown>
+  source: PluginJobCenterSource
+  slots?: Record<string, (props: { job: JobState }) => unknown>
 }) {
+  const { slots, ...props } = options
   const wrapper = mount(JobsStatusTray, {
     attachTo: document.body,
     props: {
-      ...options,
+      ...props,
       loadOnMount: false,
       teleportTo: false,
     },
+    slots,
   })
   await wrapper.get('.mint-jobs-tray__trigger').trigger('click')
   return wrapper
@@ -56,7 +60,7 @@ async function openTray(options: {
 
 describe('JobsStatusTray', () => {
   it('shows awaiting input as active without default actions', async () => {
-    const wrapper = await openTray({ jobs: [job('awaiting_input')] })
+    const wrapper = await openTray({ source: { jobs: [job('awaiting_input')] } })
 
     expect([
       wrapper.text().includes('Waiting for input'),
@@ -65,15 +69,15 @@ describe('JobsStatusTray', () => {
     ]).toEqual([true, false, false])
   })
 
-  it('shows only actions supported by both capability and adapter', async () => {
+  it('shows only actions supported by both capability and source', async () => {
     const wrapper = await openTray({
-      jobs: [
-        { ...job('awaiting_input', 'input'), can_cancel: true },
-        { ...job('completed', 'done'), can_delete: true },
-      ],
-      adapter: {
-        cancelJob: vi.fn(),
-        deleteJob: vi.fn(),
+      source: {
+        jobs: [
+          { ...job('awaiting_input', 'input'), can_cancel: true },
+          { ...job('completed', 'done'), can_delete: true },
+        ],
+        cancelJob: vi.fn(async () => undefined),
+        deleteJob: vi.fn(async () => true),
       },
     })
 
@@ -87,7 +91,7 @@ describe('JobsStatusTray', () => {
   })
 
   it('exposes dialog state and closes on Escape', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
     const trigger = wrapper.get('.mint-jobs-tray__trigger')
 
     await wrapper.get('[role="dialog"]').trigger('keydown', { key: 'Escape' })
@@ -100,15 +104,17 @@ describe('JobsStatusTray', () => {
 
   it('renders an individual delete action for an active capable job', async () => {
     const wrapper = await openTray({
-      jobs: [{ ...job('awaiting_input'), can_delete: true }],
-      adapter: { deleteJob: vi.fn() },
+      source: {
+        jobs: [{ ...job('awaiting_input'), can_delete: true }],
+        deleteJob: vi.fn(async () => true),
+      },
     })
 
     expect(wrapper.find('[aria-label="Delete job"]').exists()).toBe(true)
   })
 
   it('traps forward Tab navigation inside the modal dialog', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
     const focusable = wrapper.findAll('button')
     const firstInsidePanel = wrapper.get('[aria-label="Close jobs"]')
     const lastInsidePanel = focusable[focusable.length - 1]!
@@ -120,7 +126,7 @@ describe('JobsStatusTray', () => {
   })
 
   it('traps reverse Tab navigation from the dialog container', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
     const panel = wrapper.get('[role="dialog"]')
     const focusable = panel.findAll('button')
     const panelElement = panel.element as HTMLElement
@@ -132,10 +138,28 @@ describe('JobsStatusTray', () => {
   })
 
   it('exposes job selection through a keyboard-accessible button', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
 
     await wrapper.get('.mint-jobs-tray__job-select').trigger('click')
 
     expect(wrapper.emitted('select')?.[0]?.[0]).toMatchObject({ job_id: 'running' })
   })
+
+  it('renders the job-actions slot once per row in both tabs with the row job', async () => {
+    const wrapper = await openTray({
+      source: { jobs: [job('running', 'R-1'), job('completed', 'C-1')] },
+      slots: {
+        'job-actions': ({ job: row }) =>
+          h('button', { 'data-testid': 'open', 'data-job': row.job_id }, 'Open'),
+      },
+    })
+
+    const active = wrapper.findAll('[data-testid="open"]')
+    expect(active.map((b) => b.attributes('data-job'))).toEqual(['R-1'])
+
+    await wrapper.get('[role="tab"][data-tab="history"]').trigger('click')
+
+    const history = wrapper.findAll('[data-testid="open"]')
+    expect(history.map((b) => b.attributes('data-job'))).toEqual(['C-1'])
+  })
 })

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

@@ -50,6 +50,29 @@ describe('useAuth', () => {
     vi.restoreAllMocks()
   })
 
+  it('loads the PostgreSQL-only public auth contract', async () => {
+    mockedAxios.get.mockResolvedValueOnce({
+      data: {
+        auth_required: true,
+        passkey_enabled: true,
+        passkey_registered: false,
+        registration_enabled: true,
+        access: { experiment_visibility_mode: 'restricted' },
+      },
+    })
+
+    const config = await useAuth().fetchAuthConfig()
+    const expected = {
+      authRequired: true,
+      passkeyEnabled: true,
+      passkeyRegistered: false,
+      registrationEnabled: true,
+      experimentVisibilityMode: 'restricted',
+    }
+
+    expect([config, useAuthStore().authConfig]).toEqual([expected, expected])
+  })
+
   describe('login', () => {
     it('should set token on successful login', async () => {
       mockedAxios.post.mockResolvedValueOnce({

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

@@ -0,0 +1,140 @@
+import { effectScope } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { useEventStream } from '../../composables/useEventStream'
+
+function pendingStreamResponse(): {
+  response: Response
+  close: () => void
+} {
+  let close!: () => void
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      close = () => {
+        try {
+          controller.close()
+        } catch {
+          // stop() may already have cancelled the reader.
+        }
+      }
+    },
+  })
+  return { response: new Response(body), close }
+}
+
+describe('useEventStream', () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('should decode chunked UTF-8 and dispatch an unterminated multiline tail frame', async () => {
+    const encoded = new TextEncoder().encode(
+      ': keepalive\nevent: result\nid: event-7\ndata: first\ndata: 2 µmol',
+    )
+    const split = encoded.indexOf(0xc2) + 1
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoded.slice(0, split))
+        controller.enqueue(encoded.slice(split))
+        controller.close()
+      },
+    })
+    const onMessage = vi.fn()
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport: vi.fn(async () => new Response(body)),
+      reconnect: false,
+      onMessage,
+    }))!
+
+    await vi.waitFor(() => expect(onMessage).toHaveBeenCalledOnce())
+
+    expect(stream.lastMessage.value).toEqual({
+      event: 'result',
+      data: 'first\n2 µmol',
+      id: 'event-7',
+      retry: undefined,
+      raw: ': keepalive\nevent: result\nid: event-7\ndata: first\ndata: 2 µmol',
+    })
+    scope.stop()
+  })
+
+  it('should keep server retry delay local and send Last-Event-ID on reconnect', async () => {
+    vi.useFakeTimers()
+    const first = new Response('id: event-1\nretry: 7\ndata: first\n\n')
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(first)
+      .mockResolvedValueOnce(second.response)
+    const options = {
+      transport,
+      reconnectDelayMs: 1_000,
+    }
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', options))!
+
+    await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-1'))
+    await vi.advanceTimersByTimeAsync(7)
+
+    const secondHeaders = new Headers(transport.mock.calls[1]?.[1]?.headers)
+    expect({
+      attempts: transport.mock.calls.length,
+      lastEventId: secondHeaders.get('Last-Event-ID'),
+      configuredDelay: options.reconnectDelayMs,
+    }).toEqual({
+      attempts: 2,
+      lastEventId: 'event-1',
+      configuredDelay: 1_000,
+    })
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+
+  it('should apply control-only frames without dispatching a data message', async () => {
+    vi.useFakeTimers()
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(new Response('id: event-2\nretry: 7\n\n'))
+      .mockResolvedValueOnce(second.response)
+    const onMessage = vi.fn()
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport,
+      reconnectDelayMs: 1_000,
+      onMessage,
+    }))!
+
+    await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-2'))
+    await vi.advanceTimersByTimeAsync(7)
+
+    expect({
+      messages: onMessage.mock.calls.length,
+      reconnectCursor: new Headers(transport.mock.calls[1]?.[1]?.headers).get('Last-Event-ID'),
+    }).toEqual({ messages: 0, reconnectCursor: 'event-2' })
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+
+  it('should reconnect after an ordinary stream close', async () => {
+    vi.useFakeTimers()
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(new Response('data: first\n\n'))
+      .mockResolvedValueOnce(second.response)
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport,
+      reconnectDelayMs: 5,
+    }))!
+
+    await vi.waitFor(() => expect(stream.lastMessage.value?.data).toBe('first'))
+    await vi.advanceTimersByTimeAsync(5)
+
+    expect(transport).toHaveBeenCalledTimes(2)
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+})

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

@@ -126,6 +126,28 @@ function activeJob(
   }
 }
 
+function streamingJobTransport(): ReturnType<typeof vi.fn<GeneratedAnalysisTransport>> {
+  return vi.fn<GeneratedAnalysisTransport>(async (input, init) => {
+    const url = String(input)
+    if (url.endsWith('/generated/manifest')) return response(manifest)
+    if (url.endsWith('/jobs/sessions') && init?.method === 'GET') {
+      return response({ sessions: [] })
+    }
+    if (url.endsWith('/jobs/sessions') && init?.method === 'POST') {
+      return response({
+        id: 'session-1',
+        tab_id: 'tab-1',
+        created_at: '',
+        last_seen_at: '',
+        active_job_ids: [],
+      })
+    }
+    if (url.endsWith('/jobs/events')) return eventStream()
+    if (url.endsWith('/jobs')) return response({ jobs: [activeJob('job-1')] })
+    throw new Error(`Unexpected request: ${url}`)
+  })
+}
+
 describe('useGeneratedAnalysis', () => {
   it('is directly usable as a job center source', () => {
     const scope = effectScope()
@@ -283,6 +305,87 @@ describe('useGeneratedAnalysis', () => {
     }
   })
 
+  it('should poll active jobs while a closed stream waits to reconnect', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 1_000,
+    }))!
+
+    try {
+      await generated.initialize()
+      await vi.advanceTimersByTimeAsync(5)
+
+      expect(transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs'))).toHaveLength(2)
+    } finally {
+      generated.dispose()
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+
+  it('should not poll or reconnect a paused job stream', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 10,
+    }))!
+
+    try {
+      await generated.initialize()
+      await vi.advanceTimersByTimeAsync(0)
+      generated.pause()
+      await vi.advanceTimersByTimeAsync(20)
+
+      expect({
+        jobLists: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs')).length,
+        streams: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs/events')).length,
+      }).toEqual({ jobLists: 1, streams: 1 })
+    } finally {
+      generated.dispose()
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+
+  it('should not poll or reconnect a disposed job stream', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 10,
+    }))!
+
+    await generated.initialize()
+    await vi.advanceTimersByTimeAsync(0)
+    generated.dispose()
+    await vi.advanceTimersByTimeAsync(20)
+
+    expect({
+      jobLists: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs')).length,
+      streams: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs/events')).length,
+    }).toEqual({ jobLists: 1, streams: 1 })
+    scope.stop()
+    vi.useRealTimers()
+  })
+
   it('does not let a late submit response regress a terminal stream update', async () => {
     const terminal = completedJob('fast-service-job')
     const lateQueued = activeJob('fast-service-job')