@morscherlab/mint-sdk 1.1.0-beta.1 → 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/composables/usePluginClient.ts

@@ -546,8 +546,14 @@ function normalizePluginSettingsOptions(options: UsePluginSettingsOptions | stri
   return typeof options === 'string' ? { pluginName: options } : options
 }
 
+const PLATFORM_OWNED_SETTINGS_KEY = 'allowed_experiment_types'
+
 function cloneRecord(value: Record<string, unknown>): Record<string, unknown> {
-  return { ...value }
+  return JSON.parse(JSON.stringify(value)) as Record<string, unknown>
+}
+
+function hasOwnSetting(settings: Record<string, unknown>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(settings, key)
 }
 
 function responseSettingsPayload(response: unknown): Record<string, unknown> {
@@ -565,6 +571,43 @@ function responseSettingsPayload(response: unknown): Record<string, unknown> {
   return {}
 }
 
+function responseSettingsRevision(response: unknown): string | null {
+  if (!response || typeof response !== 'object') return null
+  const revision = (response as { revision?: unknown }).revision
+  return typeof revision === 'string' && revision ? revision : null
+}
+
+function topLevelSettingsPatch(
+  current: Record<string, unknown>,
+  keys: Iterable<string>,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    [...keys].map(key => [
+      key,
+      hasOwnSetting(current, key) ? current[key] : null,
+    ]),
+  )
+}
+
+function changedTopLevelSettingKeys(
+  current: Record<string, unknown>,
+  saved: Record<string, unknown>,
+): Set<string> {
+  return new Set(
+    [...new Set([...Object.keys(current), ...Object.keys(saved)])].filter(
+      key => JSON.stringify(current[key]) !== JSON.stringify(saved[key]),
+    ),
+  )
+}
+
+function platformOwnedSettingsPatch(settings: Record<string, unknown>): Record<string, unknown> {
+  return {
+    [PLATFORM_OWNED_SETTINGS_KEY]: hasOwnSetting(settings, PLATFORM_OWNED_SETTINGS_KEY)
+      ? settings[PLATFORM_OWNED_SETTINGS_KEY]
+      : null,
+  }
+}
+
 /** Load, edit, and persist plugin settings from platform config or the plugin-local settings router. */
 export function usePluginSettings<TSettings = Record<string, unknown>>(
   options: UsePluginSettingsOptions | string = {},
@@ -575,8 +618,9 @@ export function usePluginSettings<TSettings = Record<string, unknown>>(
   const platformApi = useApi({ baseUrl: resolvedOptions.platformApiBaseUrl ?? injectedContext?.platformApiUrl })
   const pluginApi = useApi({ baseUrl: resolvedOptions.apiBaseUrl ?? injectedContext?.plugin?.api_prefix })
 
-  const values = shallowRef<PluginSettingsValues<TSettings>>({} as PluginSettingsValues<TSettings>)
+  const values = ref({}) as Ref<PluginSettingsValues<TSettings>>
   const savedValues = shallowRef<Record<string, unknown>>({})
+  const revision = ref<string | null>(null)
   const request = useRequestSyncState('Plugin settings request failed.')
   const isLoading = ref(false)
   const isSaving = ref(false)
@@ -584,8 +628,17 @@ export function usePluginSettings<TSettings = Record<string, unknown>>(
   const resolvedPluginName = computed(() =>
     resolvedOptions.pluginName ?? plugin.value?.name ?? injectedContext?.plugin?.name ?? '',
   )
+  const usesPluginSettingsApi = computed(() => {
+    const currentPlugin = injectedContext?.plugin ?? plugin.value
+    return currentPlugin?.settings_api === 'plugin'
+      && resolvedPluginName.value === currentPlugin.name
+  })
   const usesPlatformConfig = computed(() =>
-    Boolean((isIntegrated.value || injectedContext?.isIntegrated) && resolvedPluginName.value),
+    Boolean(
+      (isIntegrated.value || injectedContext?.isIntegrated)
+      && resolvedPluginName.value
+      && !usesPluginSettingsApi.value,
+    ),
   )
   const settings = computed(() => values.value)
   const isDirty = computed(() => JSON.stringify(values.value) !== JSON.stringify(savedValues.value))
@@ -600,10 +653,11 @@ export function usePluginSettings<TSettings = Record<string, unknown>>(
     values.value = cloneRecord(nextValues) as PluginSettingsValues<TSettings>
   }
 
-  function applyLoaded(nextValues: Record<string, unknown>): void {
+  function applyLoaded(nextValues: Record<string, unknown>, nextRevision: string | null): void {
     const cloned = cloneRecord(nextValues)
     values.value = cloned as PluginSettingsValues<TSettings>
     savedValues.value = cloneRecord(cloned)
+    revision.value = nextRevision
   }
 
   async function load(): Promise<void> {
@@ -620,7 +674,10 @@ export function usePluginSettings<TSettings = Record<string, unknown>>(
           () => pluginApi.get<{ settings: Record<string, unknown>; mode?: string }>('/settings'),
           { success: 'load', errorMessage: 'Failed to load plugin settings' },
         )
-      applyLoaded(responseSettingsPayload(response))
+      applyLoaded(
+        responseSettingsPayload(response),
+        responseSettingsRevision(response),
+      )
     } catch {
       // Error state is handled by request.run().
     } finally {
@@ -636,19 +693,65 @@ export function usePluginSettings<TSettings = Record<string, unknown>>(
     isSaving.value = true
     try {
       const payload = cloneRecord(values.value)
-      const response = usesPlatformConfig.value
-        ? await request.run(
-          () => platformApi.patch<{ plugin_name: string; config: Record<string, unknown> }>(
-            `/plugins/${encodeURIComponent(resolvedPluginName.value)}/config`,
-            { config: payload },
-          ),
-          { success: 'save', errorMessage: 'Failed to save plugin settings' },
+      let response: unknown
+      if (usesPlatformConfig.value) {
+        const dirtyKeys = changedTopLevelSettingKeys(payload, savedValues.value)
+        const platformOwnedChanged = dirtyKeys.has(PLATFORM_OWNED_SETTINGS_KEY)
+        const typedKeys = [...dirtyKeys].filter(
+          key => key !== PLATFORM_OWNED_SETTINGS_KEY,
         )
-        : await request.run(
-          () => pluginApi.put<{ settings: Record<string, unknown>; mode?: string }>('/settings', payload),
+        let nextRevision = revision.value
+
+        if (typedKeys.length) {
+          response = await request.run(
+            () => platformApi.patch<{
+              plugin_name: string
+              config: Record<string, unknown>
+              revision?: string
+            }>(
+              `/plugins/${encodeURIComponent(resolvedPluginName.value)}/config`,
+              { config: topLevelSettingsPatch(payload, typedKeys) },
+            ),
+            { success: 'save', errorMessage: 'Failed to save plugin settings' },
+          )
+          nextRevision = responseSettingsRevision(response) ?? nextRevision
+        }
+
+        if (platformOwnedChanged) {
+          response = await request.run(
+            () => platformApi.patch<{
+              plugin_name: string
+              config: Record<string, unknown>
+              revision?: string
+            }>(
+              `/plugins/${encodeURIComponent(resolvedPluginName.value)}/config`,
+              { config: platformOwnedSettingsPatch(payload) },
+            ),
+            { success: 'save', errorMessage: 'Failed to save plugin settings' },
+          )
+          nextRevision = responseSettingsRevision(response) ?? nextRevision
+        }
+
+        if (!response) return true
+        applyLoaded(responseSettingsPayload(response), nextRevision)
+        return true
+      } else {
+        const ifMatch = revision.value
+          ? { headers: { 'If-Match': `"${revision.value}"` } }
+          : undefined
+        response = await request.run(
+          () => pluginApi.put<{
+            settings: Record<string, unknown>
+            mode?: string
+            revision?: string
+          }>('/settings', payload, ifMatch),
           { success: 'save', errorMessage: 'Failed to save plugin settings' },
         )
-      applyLoaded(responseSettingsPayload(response))
+      }
+      applyLoaded(
+        responseSettingsPayload(response),
+        responseSettingsRevision(response) ?? revision.value,
+      )
       return true
     } catch {
       return false