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

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

@@ -38,16 +38,24 @@ type FakeResponse = Record<string, unknown>
 
 let getResponse: FakeResponse = { plugin_name: 'drp', config: {} }
 let patchResponse: FakeResponse = { plugin_name: 'drp', config: {} }
+let putResponse: FakeResponse = { plugin_name: 'drp', config: {} }
 let getError: Error | null = null
 let patchError: Error | null = null
-let recordedCalls: { method: string; url: string; data?: unknown }[] = []
+let recordedBaseUrls: Array<string | undefined> = []
+let recordedCalls: {
+  method: string
+  url: string
+  data?: unknown
+  headers?: AxiosRequestConfig['headers']
+}[] = []
 
 function mockAxios() {
   vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
     this: unknown,
     url: string,
-    _config?: AxiosRequestConfig,
+    config?: AxiosRequestConfig,
   ) {
+    recordedBaseUrls.push(config?.baseURL)
     recordedCalls.push({ method: 'GET', url })
     if (getError) throw getError
     return { data: getResponse }
@@ -56,12 +64,23 @@ function mockAxios() {
     this: unknown,
     url: string,
     data?: unknown,
-    _config?: AxiosRequestConfig,
+    config?: AxiosRequestConfig,
   ) {
+    recordedBaseUrls.push(config?.baseURL)
     recordedCalls.push({ method: 'PATCH', url, data })
     if (patchError) throw patchError
     return { data: patchResponse }
   })
+  vi.spyOn(axios.Axios.prototype, 'put').mockImplementation(async function (
+    this: unknown,
+    url: string,
+    data?: unknown,
+    config?: AxiosRequestConfig,
+  ) {
+    recordedBaseUrls.push(config?.baseURL)
+    recordedCalls.push({ method: 'PUT', url, data, headers: config?.headers })
+    return { data: putResponse }
+  })
 }
 
 describe('usePluginConfig', () => {
@@ -70,13 +89,17 @@ describe('usePluginConfig', () => {
     autoLoadOnMount = false
     getResponse = { plugin_name: 'drp', config: {} }
     patchResponse = { plugin_name: 'drp', config: {} }
+    putResponse = { plugin_name: 'drp', config: {} }
     getError = null
     patchError = null
     recordedCalls = []
+    recordedBaseUrls = []
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
     mockAxios()
   })
 
   afterEach(() => {
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
     vi.restoreAllMocks()
   })
 
@@ -106,12 +129,148 @@ describe('usePluginConfig', () => {
     expect(recordedCalls[0]!.url).toBe('/plugins/my%2Fplugin/config')
   })
 
-  it('save PATCHes the plugin config endpoint', async () => {
-    getResponse = { plugin_name: 'drp', config: { n: 1 } }
-    patchResponse = { plugin_name: 'drp', config: { n: 2 } }
+  it.each([
+    'platform',
+    undefined,
+  ] as const)(
+    'should use the 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 } : {}),
+        },
+      }
+      getResponse = {
+        plugin_name: 'drp',
+        config: { n: 1 },
+        revision: 'revision-1',
+      }
+      const hook = usePluginConfig('drp')
+
+      await hook.load()
+
+      expect(recordedCalls).toEqual([
+        { method: 'GET', url: '/plugins/drp/config' },
+      ])
+    },
+  )
+
+  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',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'drp',
+        name: 'drp',
+        version: '1.0.0',
+        route_prefix: '/drp',
+        api_prefix: '/api/drp',
+        settings_api: 'plugin',
+      },
+    }
+    getResponse = {
+      settings: { n: 1 },
+      mode: 'integrated',
+      revision: 'revision-1',
+    }
+    putResponse = {
+      settings: { n: 2 },
+      mode: 'integrated',
+      revision: 'revision-2',
+    }
     const hook = usePluginConfig('drp')
     await hook.load()
     hook.config.value = { n: 2 }
+
+    const saved = await hook.save()
+
+    expect({
+      saved,
+      calls: recordedCalls,
+      baseUrls: recordedBaseUrls,
+      config: hook.config.value,
+    }).toEqual({
+      saved: true,
+      baseUrls: ['/api/drp', '/api/drp'],
+      calls: [
+        { method: 'GET', url: '/settings' },
+        {
+          method: 'PUT',
+          url: '/settings',
+          data: { n: 2 },
+          headers: { 'If-Match': '"revision-1"' },
+        },
+      ],
+      config: { n: 2 },
+    })
+  })
+
+  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',
+      },
+    }
+    getResponse = {
+      plugin_name: 'other-plugin',
+      config: { n: 1 },
+      revision: 'revision-1',
+    }
+
+    const hook = usePluginConfig('other-plugin')
+    await hook.load()
+
+    expect({
+      calls: recordedCalls,
+      config: hook.config.value,
+    }).toEqual({
+      calls: [
+        { method: 'GET', url: '/plugins/other-plugin/config' },
+      ],
+      config: { n: 1 },
+    })
+  })
+
+  it('should PATCH only dirty typed fields through a versioned platform facade', async () => {
+    getResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 1,
+        allowed_experiment_types: ['metabolomics'],
+      },
+      revision: 'revision-1',
+    }
+    patchResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 2,
+        allowed_experiment_types: ['metabolomics'],
+      },
+      revision: 'revision-2',
+    }
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    hook.config.value = {
+      n: 2,
+      allowed_experiment_types: ['metabolomics'],
+    }
     await nextTick()
     expect(hook.isDirty.value).toBe(true)
 
@@ -120,11 +279,168 @@ describe('usePluginConfig', () => {
     const patchCall = recordedCalls.find((c) => c.method === 'PATCH')!
     expect(patchCall.url).toBe('/plugins/drp/config')
     expect(patchCall.data).toEqual({ config: { n: 2 } })
-    expect(hook.config.value).toEqual({ n: 2 })
+    expect(patchCall.headers).toBeUndefined()
+    expect(hook.config.value).toEqual({
+      n: 2,
+      allowed_experiment_types: ['metabolomics'],
+    })
     expect(hook.isDirty.value).toBe(false)
     expect(hook.lastSavedAt.value).toBeInstanceOf(Date)
   })
 
+  it('should split changed platform-owned config from a versioned typed save', async () => {
+    getResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 1,
+        allowed_experiment_types: ['metabolomics'],
+      },
+      revision: 'revision-1',
+    }
+    patchResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 2,
+        allowed_experiment_types: ['proteomics'],
+      },
+      revision: 'untrusted-platform-revision',
+    }
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    hook.config.value = {
+      n: 2,
+      allowed_experiment_types: ['proteomics'],
+    }
+
+    const saved = await hook.save()
+    patchResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 3,
+        allowed_experiment_types: ['proteomics'],
+      },
+      revision: 'revision-3',
+    }
+    hook.config.value = {
+      n: 3,
+      allowed_experiment_types: ['proteomics'],
+    }
+    const savedAgain = await hook.save()
+
+    expect({
+      saved,
+      savedAgain,
+      calls: recordedCalls,
+      config: hook.config.value,
+      isDirty: hook.isDirty.value,
+    }).toEqual({
+      saved: true,
+      savedAgain: true,
+      calls: [
+        { method: 'GET', url: '/plugins/drp/config' },
+        {
+          method: 'PATCH',
+          url: '/plugins/drp/config',
+          data: { config: { n: 2 } },
+        },
+        {
+          method: 'PATCH',
+          url: '/plugins/drp/config',
+          data: { config: { allowed_experiment_types: ['proteomics'] } },
+        },
+        {
+          method: 'PATCH',
+          url: '/plugins/drp/config',
+          data: { config: { n: 3 } },
+        },
+      ],
+      config: {
+        n: 3,
+        allowed_experiment_types: ['proteomics'],
+      },
+      isDirty: false,
+    })
+  })
+
+  it('should avoid a typed PUT when only the platform-owned config changes', async () => {
+    getResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 1,
+        allowed_experiment_types: ['metabolomics'],
+      },
+      revision: 'revision-1',
+    }
+    patchResponse = {
+      plugin_name: 'drp',
+      config: {
+        n: 1,
+        allowed_experiment_types: ['proteomics'],
+      },
+    }
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    hook.config.value = {
+      n: 1,
+      allowed_experiment_types: ['proteomics'],
+    }
+
+    const saved = await hook.save()
+
+    expect({
+      saved,
+      calls: recordedCalls,
+      config: hook.config.value,
+    }).toEqual({
+      saved: true,
+      calls: [
+        { method: 'GET', url: '/plugins/drp/config' },
+        {
+          method: 'PATCH',
+          url: '/plugins/drp/config',
+          data: { config: { allowed_experiment_types: ['proteomics'] } },
+        },
+      ],
+      config: {
+        n: 1,
+        allowed_experiment_types: ['proteomics'],
+      },
+    })
+  })
+
+  it('should detect nested config edits and restore the saved JSON snapshot', async () => {
+    getResponse = {
+      plugin_name: 'drp',
+      config: {
+        rules: {
+          thresholds: [1, 2],
+        },
+      },
+    }
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    const rules = hook.config.value.rules as { thresholds: number[] }
+    rules.thresholds[0] = 9
+    await nextTick()
+
+    const dirtyAfterMutation = hook.isDirty.value
+    hook.reset()
+
+    expect({
+      dirtyAfterMutation,
+      config: hook.config.value,
+      isDirty: hook.isDirty.value,
+    }).toEqual({
+      dirtyAfterMutation: true,
+      config: {
+        rules: {
+          thresholds: [1, 2],
+        },
+      },
+      isDirty: false,
+    })
+  })
+
   it('isDirty reflects edits vs last saved snapshot', async () => {
     getResponse = { plugin_name: 'drp', config: { k: 'v' } }
     const hook = usePluginConfig('drp')

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 {