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

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

@@ -848,6 +848,146 @@ describe('usePluginClient', () => {
     })
   })
 
+  describe('secret settings references', () => {
+    const secretRef = { $secret: 'sec_0f2a4c6e8a0c2e4a6c8e0a2c4e6a8c0e', set: true }
+
+    function integratedPluginSettingsHost(): void {
+      ;(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',
+        },
+      }
+      nextGetData = {
+        settings: { apiKey: secretRef, method: 'first' },
+        secret_format: 'ref',
+        mode: 'integrated',
+        revision: 'revision-1',
+      }
+      nextPutData = {
+        settings: { apiKey: secretRef, method: 'second' },
+        secret_format: 'ref',
+        mode: 'integrated',
+        revision: 'revision-2',
+      }
+    }
+
+    it('should round-trip an untouched secret reference unchanged', async () => {
+      integratedPluginSettingsHost()
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      const saved = await settings.save({ ...settings.values.value, method: 'second' })
+
+      expect({ saved, body: requestBodies[0] }).toEqual({
+        saved: true,
+        body: { apiKey: secretRef, method: 'second', secret_format: 'ref' },
+      })
+    })
+
+    it('should submit a typed string when the user enters a new secret', async () => {
+      integratedPluginSettingsHost()
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      await settings.save({ apiKey: 'typed-secret', method: 'first' })
+
+      expect(requestBodies[0]).toEqual({
+        apiKey: 'typed-secret',
+        method: 'first',
+        secret_format: 'ref',
+      })
+    })
+
+    it('should submit null when the user clears a secret', async () => {
+      integratedPluginSettingsHost()
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      await settings.save({ apiKey: null, method: 'first' })
+
+      expect(requestBodies[0]).toEqual({
+        apiKey: null,
+        method: 'first',
+        secret_format: 'ref',
+      })
+    })
+
+    it('should declare the reference format on platform config patches', 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: { apiKey: secretRef, method: 'first' },
+        secret_format: 'ref',
+        revision: 'revision-1',
+      }
+      nextPatchData = {
+        plugin_name: 'drp',
+        config: { apiKey: secretRef, method: 'second' },
+        secret_format: 'ref',
+        revision: 'revision-2',
+      }
+
+      const settings = usePluginSettings<{ apiKey?: unknown; method?: string }>({
+        pluginName: 'drp',
+      })
+      await settings.load()
+      await settings.save({ apiKey: secretRef, method: 'second' })
+
+      expect(requestBodies[0]).toEqual({
+        config: { method: 'second', secret_format: 'ref' },
+      })
+    })
+
+    it('should omit the format marker for a host that does not publish one', 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',
+        },
+      }
+      nextGetData = { settings: { method: 'first' }, mode: 'integrated', revision: 'revision-1' }
+      nextPutData = { settings: { method: 'second' }, mode: 'integrated', revision: 'revision-2' }
+
+      const settings = usePluginSettings<{ method?: string }>({ pluginName: 'drp' })
+      await settings.load()
+      await settings.save({ method: 'second' })
+
+      expect(requestBodies[0]).toEqual({ method: 'second' })
+    })
+  })
+
   it('should preserve the contract v2 form schema in settingsConfig', () => {
     const settings = usePluginSettings({
       apiBaseUrl: '/api/drp',

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

@@ -0,0 +1,497 @@
+/**
+ * Tests for usePluginConfig.
+ *
+ * Covers the plugin settings life-cycle used by every plugin's
+ * settings pane:
+ *
+ * - resolvedName prefers explicit pluginName, falls back to platform plugin
+ * - load() populates config + savedConfig from /plugins/{name}/config
+ * - save() PATCHes the endpoint, updates savedConfig, returns true
+ * - isDirty reflects user edits vs last saved state
+ * - reset() restores config to savedConfig and clears error
+ * - lastLoadedAt / lastSavedAt track successful syncs
+ * - error messages bubble up from network failures
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import axios, { type AxiosRequestConfig } from 'axios'
+import { nextTick } from 'vue'
+
+// usePluginConfig calls onMounted(load); happy-dom doesn't run Vue's
+// lifecycle outside a component, so we stub onMounted to call the
+// callback synchronously if and only if the test opts in.
+let autoLoadOnMount = false
+vi.mock('vue', async () => {
+  const actual = await vi.importActual<typeof import('vue')>('vue')
+  return {
+    ...actual,
+    onMounted: vi.fn((cb: () => void) => {
+      if (autoLoadOnMount) cb()
+    }),
+  }
+})
+
+import { usePluginConfig } from '../../composables/usePluginConfig'
+
+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 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,
+  ) {
+    recordedBaseUrls.push(config?.baseURL)
+    recordedCalls.push({ method: 'GET', url })
+    if (getError) throw getError
+    return { data: getResponse }
+  })
+  vi.spyOn(axios.Axios.prototype, 'patch').mockImplementation(async function (
+    this: unknown,
+    url: string,
+    data?: unknown,
+    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', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    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()
+  })
+
+  it('load fetches config from correct endpoint and populates state', async () => {
+    getResponse = {
+      plugin_name: 'drp',
+      config: { raw_files_path: '/data/rfa', threshold: 0.5 },
+    }
+    const hook = usePluginConfig('drp')
+    await hook.load()
+
+    expect(recordedCalls).toEqual([
+      { method: 'GET', url: '/plugins/drp/config' },
+    ])
+    expect(hook.config.value).toEqual({
+      raw_files_path: '/data/rfa',
+      threshold: 0.5,
+    })
+    expect(hook.isDirty.value).toBe(false)
+    expect(hook.error.value).toBeNull()
+    expect(hook.lastLoadedAt.value).toBeInstanceOf(Date)
+  })
+
+  it('encodes special characters in plugin name', async () => {
+    const hook = usePluginConfig('my/plugin')
+    await hook.load()
+    expect(recordedCalls[0]!.url).toBe('/plugins/my%2Fplugin/config')
+  })
+
+  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)
+
+    const ok = await hook.save()
+    expect(ok).toBe(true)
+    const patchCall = recordedCalls.find((c) => c.method === 'PATCH')!
+    expect(patchCall.url).toBe('/plugins/drp/config')
+    expect(patchCall.data).toEqual({ config: { 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')
+    await hook.load()
+    expect(hook.isDirty.value).toBe(false)
+
+    hook.config.value = { k: 'changed' }
+    await nextTick()
+    expect(hook.isDirty.value).toBe(true)
+
+    hook.config.value = { k: 'v' }
+    await nextTick()
+    expect(hook.isDirty.value).toBe(false)
+  })
+
+  it('reset restores saved config and clears error', async () => {
+    getResponse = { plugin_name: 'drp', config: { k: 'v' } }
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    hook.config.value = { k: 'edited' }
+    hook.error.value = 'something'
+
+    hook.reset()
+    expect(hook.config.value).toEqual({ k: 'v' })
+    expect(hook.error.value).toBeNull()
+  })
+
+  it('load surfaces network error message', async () => {
+    getError = new Error('network down')
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    expect(hook.error.value).toBe('network down')
+    expect(hook.isLoading.value).toBe(false)
+    expect(hook.lastLoadedAt.value).toBeNull()
+  })
+
+  it('save returns false and records error on failure', async () => {
+    patchError = new Error('403')
+    const hook = usePluginConfig('drp')
+    await hook.load()
+    hook.config.value = { x: 1 }
+    const ok = await hook.save()
+    expect(ok).toBe(false)
+    expect(hook.error.value).toBe('403')
+    expect(hook.lastSavedAt.value).toBeNull()
+  })
+
+  it('empty plugin name produces a noop load', async () => {
+    const hook = usePluginConfig('')
+    await hook.load()
+    expect(recordedCalls).toEqual([])
+    expect(hook.error.value).toBeNull()
+  })
+})