@morscherlab/mint-sdk 1.0.62 → 1.1.0-beta.1

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/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, {
@@ -774,6 +789,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)

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

@@ -47,7 +47,6 @@ describe('extract docs template helpers', () => {
       group: packEntry.category,
       source: 'packages/sdk-frontend/src/templates/packs.ts',
       add_command: packEntry.add_command,
-      init_command: packEntry.init_command,
       docs_command: packEntry.docs_command,
     })
   })

package/src/__tests__/generatedUi.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  generatedJobDefaults,
+  generatedJobFormSchema,
+  normalizeGeneratedJobInput,
+} from '../generated/schema'
+import type { GeneratedJobDefinition } from '../types/generated-ui'
+
+const definition: GeneratedJobDefinition = {
+  id: 'summarize',
+  title: 'Summarize',
+  description: 'Summarize a dataset',
+  cpu: 2,
+  input_schema: {
+    type: 'object',
+    properties: {
+      threshold: { type: 'number', title: 'Threshold', default: 2.5, minimum: 0, maximum: 10 },
+      method: { type: 'string', title: 'Method', enum: ['fast', 'robust'], default: 'fast' },
+      normalize: { type: 'boolean', title: 'Normalize', default: true },
+      source: {
+        anyOf: [{ type: 'string', format: 'path' }, { type: 'null' }],
+        default: null,
+        'x-mint-component': 'path',
+      },
+    },
+    required: ['threshold'],
+  },
+  output_schema: {},
+}
+
+describe('generated UI schema adapter', () => {
+  it('maps the supported JSON Schema subset to standard FormBuilder fields', () => {
+    expect(generatedJobFormSchema(definition).sections[0]?.fields).toMatchObject([
+      { name: 'threshold', type: 'number', validation: { required: true, min: 0, max: 10 } },
+      { name: 'method', type: 'select', props: { options: ['fast', 'robust'] } },
+      { name: 'normalize', type: 'toggle' },
+      { name: 'source', type: 'path' },
+    ])
+  })
+
+  it('extracts defaults without sharing mutable input state', () => {
+    const defaults = generatedJobDefaults(definition)
+    const second = generatedJobDefaults(definition)
+    defaults.threshold = 9
+
+    expect(second).toEqual({ threshold: 2.5, method: 'fast', normalize: true, source: null })
+  })
+
+  it('preserves explicit null defaults without inventing values for missing defaults', () => {
+    const nullableDefinition: GeneratedJobDefinition = {
+      ...definition,
+      input_schema: {
+        type: 'object',
+        properties: {
+          optional_count: {
+            anyOf: [{ type: 'integer' }, { type: 'null' }],
+            default: null,
+          },
+          required_count: { type: 'integer' },
+        },
+        required: ['required_count'],
+      },
+    }
+
+    expect({
+      defaults: generatedJobDefaults(nullableDefinition),
+      fields: generatedJobFormSchema(nullableDefinition).sections[0]?.fields.map(field => ({
+        name: field.name,
+        defaultValue: field.defaultValue,
+      })),
+    }).toEqual({
+      defaults: { optional_count: null },
+      fields: [
+        { name: 'optional_count', defaultValue: null },
+        { name: 'required_count', defaultValue: undefined },
+      ],
+    })
+  })
+
+  it('keeps a selected path for SDK staging during submission', () => {
+    const selection = {
+      kind: 'path' as const,
+      files: [new File(['data'], 'data.csv')],
+      relativePaths: ['data.csv'],
+    }
+
+    expect(normalizeGeneratedJobInput(definition, {
+      threshold: 2.5,
+      source: selection,
+    })).toEqual({
+      threshold: 2.5,
+      source: selection,
+    })
+  })
+
+  it('marks path arrays as multiple path inputs', () => {
+    const listDefinition: GeneratedJobDefinition = {
+      ...definition,
+      input_schema: {
+        type: 'object',
+        properties: {
+          sources: {
+            type: 'array',
+            items: { type: 'string', format: 'path' },
+            'x-mint-component': 'path',
+          },
+        },
+        required: ['sources'],
+      },
+    }
+
+    expect(generatedJobFormSchema(listDefinition).sections[0]?.fields[0]).toMatchObject({
+      name: 'sources',
+      type: 'path',
+      props: { multiple: true },
+    })
+  })
+})

package/src/__tests__/templates/templates.test.ts

@@ -166,7 +166,7 @@ describe('bio data templates', () => {
     expect(getBioTemplatePackInfo('metabolism')?.name).toBe('omics-assay')
     expect(getBioTemplatePackInfo('metabolite profiling')?.name).toBe('omics-assay')
     expect(getBioTemplatePackInfo('metabolomics')?.components).toContain('ExperimentTimeline')
-    expect(getBioTemplatePackInfo('longitudinal')?.init_command).toBe('mint init --template longitudinal-study')
+    expect(getBioTemplatePackInfo('longitudinal')?.add_command).toBe('mint add data-template-pack longitudinal-study --page')
     expect(getBioTemplatePackInfo('gene expression')?.templates.at(-1)).toBe('qpcr-plate')
     expect(getBioTemplatePackInfo('gene-expression')?.templates.at(-1)).toBe('qpcr-plate')
     expect(searchBioTemplatePacks('WellPlate').map(entry => entry.name)).toEqual([

package/src/components/FileUploader.vue

@@ -19,7 +19,8 @@ const props = withDefaults(defineProps<Props>(), {
 })
 
 const emit = defineEmits<{
-  upload: [files: File[]]
+  upload: [files: File[], rootName?: string, relativePaths?: string[]]
+  remove: [files: File[]]
   error: [message: string]
 }>()
 
@@ -116,20 +117,31 @@ function validateFiles(files: FileList | File[]): File[] {
   return validFiles
 }
 
-function handleFiles(files: FileList | File[], folder?: string) {
+function handleFiles(
+  files: FileList | File[],
+  folder?: string,
+  explicitRelativePaths?: string[],
+) {
+  const candidates = Array.from(files)
   const validFiles = validateFiles(files)
   if (validFiles.length === 0) return
+  const relativePaths = validFiles.map((file) => {
+    const candidateIndex = candidates.indexOf(file)
+    return explicitRelativePaths?.[candidateIndex]
+      || file.webkitRelativePath
+      || (folder ? `${folder}/${file.name}` : file.name)
+  })
 
   if (isFolder.value) {
     folderName.value = folder || extractFolderName(validFiles)
     selectedFiles.value = validFiles
-    emit('upload', validFiles)
+    emit('upload', validFiles, folderName.value ?? undefined, relativePaths)
   } else if (!props.multiple) {
     selectedFiles.value = [validFiles[0]]
-    emit('upload', [validFiles[0]])
+    emit('upload', [validFiles[0]], undefined, [relativePaths[0]])
   } else {
     selectedFiles.value = [...selectedFiles.value, ...validFiles]
-    emit('upload', validFiles)
+    emit('upload', validFiles, undefined, relativePaths)
   }
 }
 
@@ -156,25 +168,39 @@ function handleDrop(event: DragEvent) {
 
 async function handleFolderDrop(items: DataTransferItemList) {
   const files: File[] = []
+  const relativePaths: string[] = []
   let folderNameFromDrop: string | undefined
 
   for (const item of Array.from(items)) {
     const entry = item.webkitGetAsEntry?.()
     if (entry?.isDirectory) {
       folderNameFromDrop = entry.name
-      await readDirectory(entry as FileSystemDirectoryEntry, files)
+      await readDirectory(
+        entry as FileSystemDirectoryEntry,
+        files,
+        relativePaths,
+        entry.name,
+      )
     } else if (entry?.isFile) {
       const file = await getFile(entry as FileSystemFileEntry)
-      if (file) files.push(file)
+      if (file) {
+        files.push(file)
+        relativePaths.push(file.name)
+      }
     }
   }
 
   if (files.length > 0) {
-    handleFiles(files, folderNameFromDrop)
+    handleFiles(files, folderNameFromDrop, relativePaths)
   }
 }
 
-async function readDirectory(directory: FileSystemDirectoryEntry, files: File[]): Promise<void> {
+async function readDirectory(
+  directory: FileSystemDirectoryEntry,
+  files: File[],
+  relativePaths: string[],
+  prefix: string,
+): Promise<void> {
   const reader = directory.createReader()
   // readEntries returns at most 100 entries per call per spec — must loop
   let batch: FileSystemEntry[]
@@ -185,9 +211,17 @@ async function readDirectory(directory: FileSystemDirectoryEntry, files: File[])
     for (const entry of batch) {
       if (entry.isFile) {
         const file = await getFile(entry as FileSystemFileEntry)
-        if (file) files.push(file)
+        if (file) {
+          files.push(file)
+          relativePaths.push(`${prefix}/${file.name}`)
+        }
       } else if (entry.isDirectory) {
-        await readDirectory(entry as FileSystemDirectoryEntry, files)
+        await readDirectory(
+          entry as FileSystemDirectoryEntry,
+          files,
+          relativePaths,
+          `${prefix}/${entry.name}`,
+        )
       }
     }
   } while (batch.length > 0)
@@ -225,15 +259,19 @@ function openFilePicker() {
 }
 
 function removeFile(index: number) {
+  const removed = selectedFiles.value[index]
   selectedFiles.value = selectedFiles.value.filter((_, i) => i !== index)
   if (isFolder.value && selectedFiles.value.length === 0) {
     folderName.value = null
   }
+  if (removed) emit('remove', [removed])
 }
 
 function clearAll() {
+  const removed = [...selectedFiles.value]
   selectedFiles.value = []
   folderName.value = null
+  if (removed.length) emit('remove', removed)
 }
 
 function formatFileSize(bytes: number): string {