@morscherlab/mint-sdk 1.3.8 → 1.4.0-beta.1

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

@@ -0,0 +1,194 @@
+import { effectScope, ref } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { MintApiError } from '../../apiErrors'
+import type { RealtimeEvent, RealtimeHandler } from '../../composables/useRealtime'
+
+const realtime = vi.hoisted(() => ({
+  topics: (): string[] => [],
+  handler: null as RealtimeHandler | null,
+}))
+
+vi.mock('../../composables/useRealtime', () => ({
+  useRealtime: (topics: () => string[], handler: RealtimeHandler) => {
+    realtime.topics = topics
+    realtime.handler = handler
+  },
+}))
+
+const { useVersionedSave } = await import('../../composables/useVersionedSave')
+
+function conflictError(details: unknown): MintApiError {
+  return new MintApiError('changed', 'experiment.version_conflict', 412, null, details, undefined, null)
+}
+
+function setup(overrides: { save?: (headers: Record<string, string>) => Promise<string> } = {}) {
+  const save = vi.fn(overrides.save ?? (async () => 'saved'))
+  const reload = vi.fn()
+  const dirty = ref(true)
+  const topic = ref<string | null>('experiment:42')
+  const scope = effectScope()
+  const versioned = scope.run(() => useVersionedSave({
+    version: 16,
+    save,
+    reload,
+    topic,
+    dirty,
+    userName: id => ({ '7': 'Alice Chen', '9': 'Dana Wu' })[id],
+  }))!
+  return { versioned, save, reload, dirty, topic, scope }
+}
+
+function emit(event: Partial<RealtimeEvent>): void {
+  realtime.handler?.({ type: 'experiment.update', topic: 'experiment:42', ...event })
+}
+
+describe('useVersionedSave', () => {
+  afterEach(() => {
+    realtime.handler = null
+  })
+
+  it('should send If-Match with the loaded version and resolve the result when the save succeeds', async () => {
+    const { versioned, save, scope } = setup()
+
+    await expect(versioned.save()).resolves.toBe('saved')
+
+    expect(save).toHaveBeenCalledWith({ 'If-Match': '"v16"' })
+    expect(versioned.conflict.value).toBeNull()
+    scope.stop()
+  })
+
+  it.each([
+    [{ version: 17 }, 17, { 'If-Match': '"v17"' }],
+    [null, null, {}],
+  ])('should open the conflict and overwrite on top of its version when the 412 details are %j', async (details, version, overwriteHeaders) => {
+    const { versioned, save, scope } = setup()
+    save.mockRejectedValueOnce(conflictError(details))
+
+    await expect(versioned.save()).resolves.toBeUndefined()
+    expect(versioned.conflict.value).toEqual({ version })
+
+    await expect(versioned.overwrite()).resolves.toBe('saved')
+    expect(save).toHaveBeenLastCalledWith(overwriteHeaders)
+    expect(versioned.conflict.value).toBeNull()
+    scope.stop()
+  })
+
+  it('should reject and keep no conflict when the save fails with another error', async () => {
+    const failure = new MintApiError('bad', 'validation.failed', 422, null, null, undefined, null)
+    const { versioned, scope } = setup({ save: async () => { throw failure } })
+
+    await expect(versioned.save()).rejects.toBe(failure)
+
+    expect(versioned.conflict.value).toBeNull()
+    scope.stop()
+  })
+
+  it('should clear the conflict and the stale change and refetch when the user reloads', async () => {
+    const { versioned, save, reload, scope } = setup()
+    save.mockRejectedValueOnce(conflictError({ version: 17 }))
+    await versioned.save()
+    emit({ actor_id: '7', fields: ['notes'] })
+
+    await versioned.reload()
+
+    expect([versioned.conflict.value, versioned.stale.value, reload.mock.calls.length]).toEqual([null, null, 1])
+    scope.stop()
+  })
+
+  it('should keep the conflict and the stale change when the reload brings no fresh record', async () => {
+    const { versioned, save, reload, scope } = setup()
+    save.mockRejectedValueOnce(conflictError({ version: 17 }))
+    await versioned.save()
+    emit({ actor_id: '7', fields: ['notes'] })
+    const failure = new Error('Could not reload')
+    reload.mockRejectedValueOnce(failure)
+
+    await expect(versioned.reload()).rejects.toBe(failure)
+
+    expect(versioned.conflict.value).toEqual({ version: 17 })
+    expect(versioned.stale.value?.actors).toEqual(['Alice Chen'])
+    scope.stop()
+  })
+
+  it('should show the writer and merge several writes when events arrive on a dirty form', () => {
+    const { versioned, reload, scope } = setup()
+
+    emit({ actor_id: '7', fields: ['notes', 'status'], at: '2026-10-23T10:00:00Z' })
+    emit({ actor_id: '9', fields: ['status', 'end_date'], at: '2026-10-23T10:00:05Z' })
+    emit({ actor_id: '7', fields: null, at: '2026-10-23T10:00:09Z' })
+
+    expect(versioned.stale.value).toEqual({
+      actors: ['Alice Chen', 'Dana Wu'],
+      fields: ['Notes', 'Status', 'End date'],
+      at: '2026-10-23T10:00:09Z',
+    })
+    expect(reload).not.toHaveBeenCalled()
+    scope.stop()
+  })
+
+  it('should refetch and show no banner when an event arrives on a clean form', () => {
+    const { versioned, reload, dirty, scope } = setup()
+    dirty.value = false
+
+    emit({ actor_id: '7', fields: ['notes'] })
+
+    expect([versioned.stale.value, reload.mock.calls.length]).toEqual([null, 1])
+    scope.stop()
+  })
+
+  // A failed background refetch only keeps the clean form as it is; the host reports it.
+  it('should not reject when the refetch for an event on a clean form fails', async () => {
+    const { versioned, reload, dirty, scope } = setup()
+    dirty.value = false
+    reload.mockRejectedValueOnce(new Error('offline'))
+
+    emit({ actor_id: '7', fields: ['notes'] })
+    await Promise.resolve()
+
+    expect([versioned.stale.value, reload.mock.calls.length]).toEqual([null, 1])
+    scope.stop()
+  })
+
+  it.each([
+    ['a resync', { type: 'resync', topic: undefined }],
+    ['an event of another topic', { topic: 'experiment:43' }],
+  ])('should ignore %s', (_label, event) => {
+    const { versioned, reload, scope } = setup()
+
+    emit(event)
+
+    expect([versioned.stale.value, reload.mock.calls.length]).toEqual([null, 0])
+    scope.stop()
+  })
+
+  it('should ignore the echo of its own save while the save runs', async () => {
+    let finish: (value: string) => void = () => {}
+    const { versioned, scope } = setup({ save: () => new Promise(resolve => { finish = resolve }) })
+
+    const pending = versioned.save()
+    emit({ actor_id: '7', fields: ['notes'] })
+
+    // A successful save clears `stale` anyway, so check before it resolves.
+    expect(versioned.stale.value).toBeNull()
+    finish('saved')
+    await pending
+    scope.stop()
+  })
+
+  // A closed form or another entity: a reopen must not show the old dialog or overwrite with its version.
+  it('should subscribe to nothing and drop the stale change and the conflict when the topic is null', async () => {
+    const { versioned, save, topic, scope } = setup()
+    save.mockRejectedValueOnce(conflictError({ version: 17 }))
+    await versioned.save()
+    emit({ actor_id: '7', fields: ['notes'] })
+
+    topic.value = null
+    await Promise.resolve()
+    expect([realtime.topics(), versioned.stale.value, versioned.conflict.value]).toEqual([[], null, null])
+
+    topic.value = 'experiment:42'
+    await Promise.resolve()
+    expect(versioned.conflict.value).toBeNull()
+    scope.stop()
+  })
+})

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

@@ -153,4 +153,40 @@ defineSlots<{
       ],
     })
   })
+
+  it('reads inline props, nested prop types, and commented slots of a generic component', () => {
+    const dir = createTempDir()
+    const componentPath = join(dir, 'src', 'components', 'Picker.vue')
+    mkdirSync(join(dir, 'src', 'components'), { recursive: true })
+    writeFileSync(componentPath, `
+<script setup lang="ts" generic="M extends boolean = false">
+/** Pick options. */
+withDefaults(defineProps<{
+  options: string[]
+  fallback?: {
+    media_type: string
+    data: string
+  }
+  size?: 'sm' | 'md'
+}>(), {
+  size: 'md',
+})
+
+defineSlots<{
+  /** \`searchable\` only: custom option row. */
+  option?: () => unknown
+}>()
+</script>
+`)
+
+    expect(extractComponent(componentPath, 'Picker', 'base', dir)).toMatchObject({
+      description: 'Pick options.',
+      props: [
+        { name: 'options', type: 'string[]', required: true },
+        { name: 'fallback', type: '{ media_type: string, data: string }', required: false },
+        { name: 'size', default: "'md'", required: false },
+      ],
+      slots: [{ name: 'option' }],
+    })
+  })
 })

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

@@ -75,7 +75,7 @@ describe('extract docs parsing helpers', () => {
        *
        * @example Recommended
        * \`\`\`vue
-       * <ExperimentSelectorModal v-model="open" />
+       * <ExperimentSelectorModal v-model:open="open" />
        * \`\`\`
        */
     `
@@ -84,7 +84,7 @@ describe('extract docs parsing helpers', () => {
       {
         title: 'Recommended',
         language: 'vue',
-        code: '<ExperimentSelectorModal v-model="open" />',
+        code: '<ExperimentSelectorModal v-model:open="open" />',
       },
     ])
   })

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

@@ -2,10 +2,7 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
-import {
-  extractCssVariables,
-  extractTailwindPreset,
-} from '../../../scripts/extract-docs-theme'
+import { extractCssVariables } from '../../../scripts/extract-docs-theme'
 
 const tempDirs: string[] = []
 
@@ -44,46 +41,4 @@ describe('extract docs theme helpers', () => {
       ],
     })
   })
-
-  it('extracts Tailwind color groups and font families', () => {
-    const dir = createTempDir()
-    const presetPath = join(dir, 'tailwind.preset.ts')
-    writeFileSync(presetPath, `
-export default {
-  theme: {
-    extend: {
-      colors: {
-        mint: {
-          50: "#f0fdfa",
-          600: "#0d9488",
-        },
-        bg: {
-          canvas: "var(--bg-default)",
-        },
-      },
-      fontFamily: {
-        sans: ['Inter', 'sans-serif'],
-        mono: ["JetBrains Mono", "monospace"],
-      },
-    },
-  },
-}
-`)
-
-    expect(extractTailwindPreset(presetPath)).toMatchObject({
-      colors: {
-        mint: {
-          50: '#f0fdfa',
-          600: '#0d9488',
-        },
-        bg: {
-          canvas: 'var(--bg-default)',
-        },
-      },
-      fontFamily: {
-        sans: 'Inter',
-        mono: 'JetBrains Mono',
-      },
-    })
-  })
 })