@morscherlab/mint-sdk 1.0.63 → 1.1.0-beta.2

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

@@ -2,7 +2,12 @@ import { mount } from '@vue/test-utils'
 import { defineComponent, nextTick, ref, shallowRef } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
 
-import { useJobsStatusTray, type UseJobsStatusTrayOptions } from '../../composables/useJobsStatusTray'
+import {
+  combinePluginJobSources,
+  useJobsStatusTray,
+  usePluginJobCenter,
+  type UseJobsStatusTrayOptions,
+} from '../../composables/useJobsStatusTray'
 import type { JobState, JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
@@ -62,6 +67,179 @@ function deferred<T>(): {
 }
 
 describe('useJobsStatusTray', () => {
+  it('combines live source jobs and fans out or routes source actions', async () => {
+    const firstJobs = shallowRef([job('running', 'first')])
+    const secondJobs = shallowRef([job('completed', 'second')])
+    const firstRefresh = vi.fn(async () => firstJobs.value)
+    const secondRefresh = vi.fn(async () => secondJobs.value)
+    const secondCancel = vi.fn(async (jobId: string) => job('cancelled', jobId))
+    const firstClear = vi.fn(async () => 1)
+    const secondClear = vi.fn(async () => 2)
+    const firstDispose = vi.fn()
+    const secondDispose = vi.fn()
+    const combined = combinePluginJobSources([
+      {
+        jobs: firstJobs,
+        refreshJobs: firstRefresh,
+        clearFinishedJobs: firstClear,
+        dispose: firstDispose,
+      },
+      {
+        jobs: secondJobs,
+        refreshJobs: secondRefresh,
+        cancelJob: secondCancel,
+        clearFinishedJobs: secondClear,
+        dispose: secondDispose,
+      },
+    ])
+
+    expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'second'])
+    secondJobs.value = [job('running', 'replacement')]
+    await nextTick()
+    expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'replacement'])
+
+    await combined.refreshJobs?.()
+    await combined.cancelJob?.('replacement')
+    await expect(combined.clearFinishedJobs?.()).resolves.toBe(3)
+    combined.dispose?.()
+
+    expect({
+      refreshes: [firstRefresh.mock.calls.length, secondRefresh.mock.calls.length],
+      cancelled: secondCancel.mock.calls[0]?.[0],
+      disposed: [firstDispose.mock.calls.length, secondDispose.mock.calls.length],
+    }).toEqual({
+      refreshes: [1, 1],
+      cancelled: 'replacement',
+      disposed: [1, 1],
+    })
+  })
+
+  it('retains every failure when disposing combined sources', () => {
+    const firstFailure = new Error('first dispose failed')
+    const secondFailure = { source: 'second', reason: 'dispose failed' }
+    const finalDispose = vi.fn()
+    const combined = combinePluginJobSources([
+      {
+        jobs: [],
+        dispose: () => {
+          throw firstFailure
+        },
+      },
+      {
+        jobs: [],
+        dispose: () => {
+          throw secondFailure
+        },
+      },
+      { jobs: [], dispose: finalDispose },
+    ])
+
+    let failure: unknown
+    try {
+      combined.dispose?.()
+    } catch (cause) {
+      failure = cause
+    }
+
+    expect(failure).toMatchObject({
+      name: 'PluginJobSourceDisposeError',
+      message: 'Failed to dispose plugin job sources',
+      cause: firstFailure,
+      errors: [firstFailure, secondFailure],
+    })
+    expect(finalDispose).toHaveBeenCalledOnce()
+  })
+
+  it('rejects duplicate ids instead of routing to an arbitrary combined source', async () => {
+    const firstCancel = vi.fn(async () => undefined)
+    const secondCancel = vi.fn(async () => undefined)
+    const combined = combinePluginJobSources([
+      { jobs: [job('running', 'duplicate')], cancelJob: firstCancel },
+      { jobs: [job('queued', 'duplicate')], cancelJob: secondCancel },
+    ])
+
+    expect(() => combined.jobs.value).toThrow('Duplicate plugin job id')
+    await expect(combined.cancelJob?.('duplicate')).rejects.toThrow('Duplicate plugin job id')
+    expect([firstCancel.mock.calls.length, secondCancel.mock.calls.length]).toEqual([0, 0])
+  })
+
+  it('does not expose a partial bulk clear across combined sources', () => {
+    const combined = combinePluginJobSources([
+      { jobs: [job('completed', 'first')], clearFinishedJobs: async () => 1 },
+      { jobs: [job('completed', 'second')] },
+    ])
+
+    expect(combined.clearFinishedJobs).toBeUndefined()
+  })
+
+  it('does not partially delete finished jobs when one combined source cannot delete', async () => {
+    const firstDelete = vi.fn(async () => true)
+    const combined = combinePluginJobSources([
+      { jobs: [job('completed', 'first')], deleteJob: firstDelete },
+      { jobs: [job('completed', 'second')] },
+    ])
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({ source: combined, loadOnMount: false })
+        return () => null
+      },
+    }))
+
+    expect(combined.deleteJob).toBeUndefined()
+    expect(center.canClearFinished.value).toBe(false)
+    await expect(center.clearFinished()).resolves.toBe(false)
+    expect(firstDelete).not.toHaveBeenCalled()
+
+    wrapper.unmount()
+  })
+
+  it('derives jobs directly from a canonical source ref', async () => {
+    const sourceJobs = shallowRef([job('queued', 'first')])
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({
+          source: { jobs: sourceJobs },
+          loadOnMount: false,
+        })
+        return () => null
+      },
+    }))
+
+    sourceJobs.value = [job('running', 'replacement')]
+    await nextTick()
+
+    expect(center.jobs.value.map(item => item.job_id)).toEqual(['replacement'])
+    wrapper.unmount()
+  })
+
+  it('delegates actions by id and leaves source mutation with the source', async () => {
+    const sourceJobs = shallowRef([job('running', 'fit')])
+    const cancelJob = vi.fn(async (jobId: string) => {
+      sourceJobs.value = [job('cancelled', jobId)]
+      return sourceJobs.value[0]
+    })
+    let center!: ReturnType<typeof usePluginJobCenter>
+    const wrapper = mount(defineComponent({
+      setup() {
+        center = usePluginJobCenter({
+          source: { jobs: sourceJobs, cancelJob },
+          loadOnMount: false,
+        })
+        return () => null
+      },
+    }))
+
+    await center.cancelJob(center.jobs.value[0]!)
+
+    expect([cancelJob.mock.calls[0]?.[0], center.jobs.value[0]?.status]).toEqual([
+      'fit',
+      'cancelled',
+    ])
+    wrapper.unmount()
+  })
+
   it('keeps awaiting input jobs in the active group', () => {
     const { tray } = mountComposable({
       jobs: [job('awaiting_input')],

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

@@ -17,6 +17,11 @@ vi.mock('vue', async () => {
 })
 
 import { usePlatformContext } from '../../composables/usePlatformContext'
+import type { PlatformContext } from '../../types'
+
+type InjectedPlatformWindow = Window & {
+  __MINT_PLATFORM__?: PlatformContext
+}
 
 function sendThemeMessage(origin: string, theme: 'light' | 'dark' | 'system'): void {
   if (!messageHandler) {
@@ -37,6 +42,7 @@ describe('usePlatformContext', () => {
   beforeEach(() => {
     unmountedCallbacks.length = 0
     messageHandler = null
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
 
     vi.spyOn(window, 'addEventListener').mockImplementation((type, listener) => {
       if (type === 'message') {
@@ -51,9 +57,31 @@ describe('usePlatformContext', () => {
       const callback = unmountedCallbacks.pop()
       callback?.()
     }
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
     vi.restoreAllMocks()
   })
 
+  it('preserves the injected plugin settings API capability', () => {
+    const injectedContext: PlatformContext = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'test-plugin',
+        name: 'test-plugin',
+        version: '1.0.0',
+        route_prefix: '/test-plugin',
+        api_prefix: '/api/test-plugin',
+        settings_api: 'plugin',
+      },
+    }
+    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = injectedContext
+
+    const context = usePlatformContext()
+
+    expect(context.plugin.value?.settings_api).toBe('plugin')
+  })
+
   it('clears allowAnyOrigin policy after last consumer unmounts', () => {
     const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 

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

@@ -156,6 +156,21 @@ describe('usePluginClient', () => {
     expect(requestConfigs[0]!.url).toBe('/health')
   })
 
+  it('omits MINT auth transport for a public generated endpoint', async () => {
+    const client = createPluginClient(contract, {
+      endpoints: {
+        health: { method: 'get', path: '/health', requiresAuth: false },
+      },
+    })
+
+    await client.health()
+
+    expect(
+      (requestConfigs[0] as AxiosRequestConfig & { _mintSkipAuth?: boolean })
+        ._mintSkipAuth,
+    ).toBe(true)
+  })
+
   it('VITE_API_PREFIX overrides contract apiPrefix', async () => {
     vi.stubEnv('VITE_API_PREFIX', '/api/override')
     const client = createPluginClient(contract, {
@@ -672,7 +687,79 @@ describe('usePluginClient', () => {
     expect(requestConfigs).toHaveLength(0)
   })
 
-  it('loads and saves plugin settings through the integrated platform config endpoint', async () => {
+  it.each([
+    'platform',
+    undefined,
+  ] as const)(
+    'should use the integrated platform config facade when settings_api is %s',
+    async (settingsApi) => {
+      ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
+        isIntegrated: true,
+        theme: 'light',
+        platformApiUrl: '/api',
+        plugin: {
+          id: 'drp',
+          name: 'drp',
+          version: '1.0.0',
+          route_prefix: '/drp',
+          api_prefix: '/api/drp',
+          ...(settingsApi ? { settings_api: settingsApi } : {}),
+        },
+      }
+      nextGetData = {
+        plugin_name: 'drp',
+        config: {
+          nasBasePath: '/data',
+          allowed_experiment_types: ['metabolomics'],
+        },
+        revision: 'revision-1',
+      }
+      nextPatchData = {
+        plugin_name: 'drp',
+        config: {
+          nasBasePath: '/mnt',
+          allowed_experiment_types: ['metabolomics'],
+        },
+        revision: 'revision-2',
+      }
+
+      const settings = usePluginSettings<{ nasBasePath?: string }>({ pluginName: 'drp' })
+      await settings.load()
+
+      expect(requestConfigs[0]!.baseURL).toBe('/api')
+      expect(requestConfigs[0]!.url).toBe('/plugins/drp/config')
+      expect(settings.values.value).toEqual({
+        nasBasePath: '/data',
+        allowed_experiment_types: ['metabolomics'],
+      })
+      expect(settings.settings.value).toEqual({
+        nasBasePath: '/data',
+        allowed_experiment_types: ['metabolomics'],
+      })
+      expect(settings.isDirty.value).toBe(false)
+
+      settings.setValues({
+        nasBasePath: '/mnt',
+        allowed_experiment_types: ['metabolomics'],
+      })
+      expect(settings.isDirty.value).toBe(true)
+      const ok = await settings.save()
+
+      expect(ok).toBe(true)
+      expect(requestConfigs[1]!.baseURL).toBe('/api')
+      expect(requestConfigs[1]!.url).toBe('/plugins/drp/config')
+      expect(requestMethods[1]).toBe('patch')
+      expect(requestConfigs[1]!.headers).toBeUndefined()
+      expect(requestBodies[0]).toEqual({ config: { nasBasePath: '/mnt' } })
+      expect(settings.values.value).toEqual({
+        nasBasePath: '/mnt',
+        allowed_experiment_types: ['metabolomics'],
+      })
+      expect(settings.isDirty.value).toBe(false)
+    },
+  )
+
+  it('should use the plugin settings router for an integrated plugin capability', async () => {
     ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
       isIntegrated: true,
       theme: 'light',
@@ -683,35 +770,271 @@ describe('usePluginClient', () => {
         version: '1.0.0',
         route_prefix: '/drp',
         api_prefix: '/api/drp',
+        settings_api: 'plugin',
       },
     }
-    nextGetData = { plugin_name: 'drp', config: { nasBasePath: '/data' } }
-    nextPatchData = { plugin_name: 'drp', config: { nasBasePath: '/mnt' } }
+    nextGetData = {
+      settings: { threshold: 1 },
+      mode: 'integrated',
+      revision: 'revision-1',
+    }
+    nextPutData = {
+      settings: { threshold: 2 },
+      mode: 'integrated',
+      revision: 'revision-2',
+    }
 
-    const settings = usePluginSettings<{ nasBasePath?: string }>({ pluginName: 'drp' })
+    const settings = usePluginSettings<{ threshold?: number }>({ pluginName: 'drp' })
     await settings.load()
+    const saved = await settings.save({ threshold: 2 })
 
-    expect(requestConfigs[0]!.baseURL).toBe('/api')
-    expect(requestConfigs[0]!.url).toBe('/plugins/drp/config')
-    expect(settings.values.value).toEqual({ nasBasePath: '/data' })
-    expect(settings.settings.value).toEqual({ nasBasePath: '/data' })
-    expect(settings.isDirty.value).toBe(false)
+    expect({
+      saved,
+      methods: requestMethods,
+      requests: requestConfigs.map(({ baseURL, url, headers }) => ({
+        baseURL,
+        url,
+        headers,
+      })),
+      bodies: requestBodies,
+      values: settings.values.value,
+    }).toEqual({
+      saved: true,
+      methods: ['get', 'put'],
+      requests: [
+        {
+          baseURL: '/api/drp',
+          url: '/settings',
+          headers: undefined,
+        },
+        {
+          baseURL: '/api/drp',
+          url: '/settings',
+          headers: { 'If-Match': '"revision-1"' },
+        },
+      ],
+      bodies: [{ threshold: 2 }],
+      values: { threshold: 2 },
+    })
+  })
 
-    settings.setValues({ nasBasePath: '/mnt' })
-    expect(settings.isDirty.value).toBe(true)
-    const ok = await settings.save()
+  it('should use the platform facade for an explicit different plugin name', async () => {
+    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'current-plugin',
+        name: 'current-plugin',
+        version: '1.0.0',
+        route_prefix: '/current-plugin',
+        api_prefix: '/api/current-plugin',
+        settings_api: 'plugin',
+      },
+    }
+    nextGetData = {
+      plugin_name: 'other-plugin',
+      config: { threshold: 1 },
+      revision: 'revision-1',
+    }
 
-    expect(ok).toBe(true)
-    expect(requestConfigs[1]!.baseURL).toBe('/api')
-    expect(requestConfigs[1]!.url).toBe('/plugins/drp/config')
-    expect(requestBodies[0]).toEqual({ config: { nasBasePath: '/mnt' } })
-    expect(settings.values.value).toEqual({ nasBasePath: '/mnt' })
-    expect(settings.isDirty.value).toBe(false)
+    const settings = usePluginSettings<{ threshold?: number }>({
+      pluginName: 'other-plugin',
+    })
+    await settings.load()
+
+    expect({
+      method: requestMethods[0],
+      baseURL: requestConfigs[0]!.baseURL,
+      url: requestConfigs[0]!.url,
+      values: settings.values.value,
+    }).toEqual({
+      method: 'get',
+      baseURL: '/api',
+      url: '/plugins/other-plugin/config',
+      values: { threshold: 1 },
+    })
+  })
+
+  it('should split changed platform-owned settings from a versioned typed save', async () => {
+    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'drp',
+        name: 'drp',
+        version: '1.0.0',
+        route_prefix: '/drp',
+        api_prefix: '/api/drp',
+      },
+    }
+    nextGetData = {
+      plugin_name: 'drp',
+      config: {
+        threshold: 1,
+        allowed_experiment_types: ['metabolomics'],
+      },
+      revision: 'revision-1',
+    }
+    nextPatchData = {
+      plugin_name: 'drp',
+      config: {
+        threshold: 2,
+        allowed_experiment_types: ['proteomics'],
+      },
+      revision: 'untrusted-platform-revision',
+    }
+    const settings = usePluginSettings<{ threshold?: number }>({ pluginName: 'drp' })
+    await settings.load()
+    settings.setValues({
+      threshold: 2,
+      allowed_experiment_types: ['proteomics'],
+    })
+
+    const saved = await settings.save()
+    nextPatchData = {
+      plugin_name: 'drp',
+      config: {
+        threshold: 3,
+        allowed_experiment_types: ['proteomics'],
+      },
+      revision: 'revision-3',
+    }
+    settings.setValues({
+      threshold: 3,
+      allowed_experiment_types: ['proteomics'],
+    })
+    const savedAgain = await settings.save()
+
+    expect({
+      saved,
+      savedAgain,
+      methods: requestMethods,
+      bodies: requestBodies,
+      writeHeaders: requestConfigs.slice(1).map(config => config.headers),
+      values: settings.values.value,
+      isDirty: settings.isDirty.value,
+    }).toEqual({
+      saved: true,
+      savedAgain: true,
+      methods: ['get', 'patch', 'patch', 'patch'],
+      bodies: [
+        { config: { threshold: 2 } },
+        { config: { allowed_experiment_types: ['proteomics'] } },
+        { config: { threshold: 3 } },
+      ],
+      writeHeaders: [undefined, undefined, undefined],
+      values: {
+        threshold: 3,
+        allowed_experiment_types: ['proteomics'],
+      },
+      isDirty: false,
+    })
+  })
+
+  it('should avoid a typed PUT when only the platform-owned setting changes', async () => {
+    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'drp',
+        name: 'drp',
+        version: '1.0.0',
+        route_prefix: '/drp',
+        api_prefix: '/api/drp',
+      },
+    }
+    nextGetData = {
+      plugin_name: 'drp',
+      config: {
+        threshold: 1,
+        allowed_experiment_types: ['metabolomics'],
+      },
+      revision: 'revision-1',
+    }
+    nextPatchData = {
+      plugin_name: 'drp',
+      config: {
+        threshold: 1,
+        allowed_experiment_types: ['proteomics'],
+      },
+    }
+
+    const settings = usePluginSettings<{ threshold?: number }>({ pluginName: 'drp' })
+    await settings.load()
+    settings.setValues({
+      threshold: 1,
+      allowed_experiment_types: ['proteomics'],
+    })
+
+    const saved = await settings.save()
+
+    expect({
+      saved,
+      methods: requestMethods,
+      bodies: requestBodies,
+      values: settings.values.value,
+    }).toEqual({
+      saved: true,
+      methods: ['get', 'patch'],
+      bodies: [{ config: { allowed_experiment_types: ['proteomics'] } }],
+      values: {
+        threshold: 1,
+        allowed_experiment_types: ['proteomics'],
+      },
+    })
+  })
+
+  it('should detect nested settings edits and restore the saved JSON snapshot', async () => {
+    nextGetData = {
+      settings: {
+        rules: {
+          thresholds: [1, 2],
+        },
+      },
+      mode: 'standalone',
+    }
+
+    const settings = usePluginSettings<{
+      rules?: { thresholds: number[] }
+    }>({
+      apiBaseUrl: '/api/drp',
+      loadOnMount: false,
+    })
+    await settings.load()
+    settings.values.value.rules!.thresholds[0] = 9
+
+    const dirtyAfterMutation = settings.isDirty.value
+    settings.reset()
+
+    expect({
+      dirtyAfterMutation,
+      values: settings.values.value,
+      isDirty: settings.isDirty.value,
+    }).toEqual({
+      dirtyAfterMutation: true,
+      values: {
+        rules: {
+          thresholds: [1, 2],
+        },
+      },
+      isDirty: false,
+    })
   })
 
   it('loads and saves plugin settings through the standalone settings router', async () => {
-    nextGetData = { settings: { nas_base_path: '/data' }, mode: 'standalone' }
-    nextPutData = { settings: { nas_base_path: '/mnt' }, mode: 'standalone' }
+    nextGetData = {
+      settings: { nas_base_path: '/data' },
+      mode: 'standalone',
+      revision: 'revision-1',
+    }
+    nextPutData = {
+      settings: { nas_base_path: '/mnt' },
+      mode: 'standalone',
+      revision: 'revision-2',
+    }
 
     const settings = usePluginSettings<{ nas_base_path?: string }>({
       apiBaseUrl: '/api/drp',
@@ -725,6 +1048,7 @@ describe('usePluginClient', () => {
     expect(requestConfigs[0]!.url).toBe('/settings')
     expect(requestConfigs[1]!.baseURL).toBe('/api/drp')
     expect(requestConfigs[1]!.url).toBe('/settings')
+    expect(requestConfigs[1]!.headers).toEqual({ 'If-Match': '"revision-1"' })
     expect(requestBodies[0]).toEqual({ nas_base_path: '/mnt' })
     expect(settings.settingsConfig.value.values).toEqual({ nas_base_path: '/mnt' })
   })
@@ -774,6 +1098,28 @@ describe('usePluginClient', () => {
     expect(stream.lastEventId.value).toBe('7')
   })
 
+  it('omits MINT auth from a public plugin event stream', async () => {
+    const authStore = useAuthStore()
+    authStore.setToken('stream-token', 3600)
+    const fetchMock = vi.fn<typeof fetch>(async () =>
+      new Response(new ReadableStream({ start: controller => controller.close() }), {
+        status: 200,
+      }),
+    )
+    vi.stubGlobal('fetch', fetchMock)
+
+    usePluginEventStream(
+      contract,
+      { method: 'get', path: '/public/events', requiresAuth: false },
+      { reconnect: false },
+    )
+
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledOnce())
+    const [, init] = fetchMock.mock.calls[0]!
+
+    expect((init?.headers as Headers).get('Authorization')).toBeNull()
+  })
+
   it('normalizes stream auth failures and does not reconnect rejected requests', async () => {
     const authStore = useAuthStore()
     authStore.setToken('expired-stream-token', 3600)