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

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/__tests__/types/GeneratedJsonSchema.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+
+import type { GeneratedJsonSchema } from '../../types/generated-ui'
+
+describe('GeneratedJsonSchema', () => {
+  it('should accept minimum array size constraints emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = { minItems: 1 }
+
+    expect(schema.minItems).toBe(1)
+  })
+
+  it('should accept array size constraints emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = { maxItems: 100 }
+
+    expect(schema.maxItems).toBe(100)
+  })
+
+  it('should accept write-only fields emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = { writeOnly: true }
+
+    expect(schema.writeOnly).toBe(true)
+  })
+
+  it('should accept tuple item schemas emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = {
+      prefixItems: [{ type: 'string' }, { type: 'number' }],
+    }
+
+    expect(schema.prefixItems).toHaveLength(2)
+  })
+
+  it('should accept exclusive numeric bounds emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = { exclusiveMinimum: 0 }
+
+    expect(schema.exclusiveMinimum).toBe(0)
+  })
+
+  it('should accept string patterns emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = { pattern: '^[0-9a-f]{64}$' }
+
+    expect(schema.pattern).toBe('^[0-9a-f]{64}$')
+  })
+
+  it('should accept discriminators emitted for Pydantic unions', () => {
+    const schema: GeneratedJsonSchema = {
+      discriminator: {
+        propertyName: 'kind',
+        mapping: { targeted: '#/$defs/TargetedResult' },
+      },
+    }
+
+    expect(schema.discriminator?.propertyName).toBe('kind')
+  })
+
+  it('should accept exclusive union branches emitted by Pydantic', () => {
+    const schema: GeneratedJsonSchema = {
+      oneOf: [{ $ref: '#/$defs/TargetedResult' }],
+    }
+
+    expect(schema.oneOf).toHaveLength(1)
+  })
+})

package/src/components/BaseSelect.vue

@@ -1,9 +1,12 @@
 <script setup lang="ts">
 /** Renders a native `<select>` element with size, error, and disabled states. */
-import { computed } from 'vue'
+import { computed, useAttrs } from 'vue'
+import type { HTMLAttributes } from 'vue'
 import type { SelectOption, SelectOptionInput } from '../types'
 import { findOptionByDomValue, normalizeOptionInput } from '../utils/options'
 
+defineOptions({ inheritAttrs: false })
+
 interface Props {
   modelValue?: string | number
   options: SelectOptionInput<string | number>[]
@@ -19,6 +22,16 @@ const props = withDefaults(defineProps<Props>(), {
   error: false,
   size: 'md',
 })
+const attrs = useAttrs()
+
+const controlAttrs = computed(() => {
+  const { class: _class, style: _style, ...nativeAttrs } = attrs
+  return nativeAttrs
+})
+const wrapperAttrs = computed<Pick<HTMLAttributes, 'class' | 'style'>>(() => ({
+  class: attrs.class as HTMLAttributes['class'],
+  style: attrs.style as HTMLAttributes['style'],
+}))
 
 const emit = defineEmits<{
   'update:modelValue': [value: string | number]
@@ -36,8 +49,9 @@ function handleChange(event: Event) {
 </script>
 
 <template>
-  <div class="mint-select">
+  <div v-bind="wrapperAttrs" class="mint-select">
     <select
+      v-bind="controlAttrs"
       :value="modelValue"
       :disabled="disabled"
       :aria-invalid="error || undefined"

package/src/components/BaseToggle.vue

@@ -5,6 +5,8 @@ import Tooltip from './Tooltip.vue'
 interface Props {
   modelValue?: boolean
   label?: string
+  /** Accessible switch name; defaults to the visual label, then "Toggle". */
+  ariaLabel?: string
   description?: string
   icon?: string | string[]
   iconColor?: string
@@ -111,7 +113,7 @@ function iconStyle(): Record<string, string> {
       role="switch"
       :tabindex="disabled ? -1 : 0"
       :aria-checked="modelValue"
-      :aria-label="label || 'Toggle'"
+      :aria-label="ariaLabel || label || 'Toggle'"
       :class="[
         'mint-toggle__track',
         `mint-toggle__track--${size}`,