@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.5

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

@@ -0,0 +1,338 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { nextTick } from 'vue'
+import axios, { type AxiosRequestConfig } from 'axios'
+
+import { useExperimentSelector } from '../../composables/useExperimentSelector'
+import { useApi } from '../../composables/useApi'
+import type { ExperimentListResponse, ExperimentSummary } from '../../types'
+
+let fakeResponse: ExperimentListResponse
+let fakeError: Error | null = null
+let recordedUrls: string[] = []
+
+function experiment(id: number, overrides: Partial<ExperimentSummary> = {}): ExperimentSummary {
+  return {
+    id,
+    name: `Experiment ${id}`,
+    status: 'planned',
+    experiment_type: 'screen',
+    created_at: '2026-05-07T08:00:00Z',
+    updated_at: '2026-05-07T08:00:00Z',
+    has_design_data: false,
+    ...overrides,
+  }
+}
+
+function deferredResponse() {
+  let resolve!: (value: { data: ExperimentListResponse }) => void
+  const promise = new Promise<{ data: ExperimentListResponse }>((resolvePromise) => {
+    resolve = resolvePromise
+  })
+  return { promise, resolve }
+}
+
+describe('useExperimentSelector', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    fakeResponse = {
+      experiments: [experiment(1)],
+      total: 1,
+    }
+    fakeError = null
+    recordedUrls = []
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      if (fakeError) throw fakeError
+      return { data: fakeResponse }
+    })
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  it('fetches experiments, tracks loading, and marks lastLoadedAt', async () => {
+    let resolveGet!: (value: { data: ExperimentListResponse }) => void
+    vi.mocked(axios.Axios.prototype.get).mockImplementationOnce(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      return new Promise((resolve) => {
+        resolveGet = resolve
+      })
+    })
+
+    const hook = useExperimentSelector({ limit: 25 })
+    expect(hook.isLoading.value).toBe(false)
+    expect(hook.lastLoadedAt.value).toBeNull()
+
+    const promise = hook.fetch()
+    expect(hook.isLoading.value).toBe(true)
+
+    resolveGet({ data: fakeResponse })
+    await promise
+
+    expect(hook.isLoading.value).toBe(false)
+    expect(hook.error.value).toBeNull()
+    expect(hook.experiments.value).toHaveLength(1)
+    expect(hook.total.value).toBe(1)
+    expect(hook.lastLoadedAt.value).toBeInstanceOf(Date)
+    expect(recordedUrls[0]).toContain('/experiments?')
+    expect(recordedUrls[0]).toContain('limit=25')
+    expect(recordedUrls[0]).toContain('skip=0')
+    expect(recordedUrls[0]).toContain('sort_by=created_at')
+  })
+
+  it('uses a single allowed experiment type as the platform query filter', async () => {
+    const hook = useExperimentSelector({
+      allowedExperimentTypes: ['drug-response'],
+    })
+
+    await hook.fetch()
+
+    expect(recordedUrls[0]).toContain('experiment_type=drug-response')
+  })
+
+  it('returns an empty page without querying when the selected type is not allowed', async () => {
+    const hook = useExperimentSelector({
+      experimentType: 'proteomics',
+      allowedExperimentTypes: ['drug-response'],
+    })
+
+    await hook.fetch()
+
+    expect(recordedUrls).toEqual([])
+    expect(hook.experiments.value).toEqual([])
+    expect(hook.total.value).toBe(0)
+  })
+
+  it('queries each allowed experiment type and merges multi-type pages', async () => {
+    vi.spyOn(useApi().client, 'get').mockImplementation(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      const type = new URL(url, 'http://mint.test').searchParams.get('experiment_type')
+      if (type === 'drug-response') {
+        return {
+          data: {
+            experiments: [experiment(1, {
+              experiment_type: 'drug-response',
+              created_at: '2026-05-08T08:00:00Z',
+            })],
+            total: 1,
+          },
+        }
+      }
+      if (type === 'metabolomics') {
+        return {
+          data: {
+            experiments: [experiment(2, {
+              experiment_type: 'metabolomics',
+              created_at: '2026-05-09T08:00:00Z',
+            })],
+            total: 1,
+          },
+        }
+      }
+      return { data: { experiments: [], total: 0 } }
+    })
+
+    const hook = useExperimentSelector({
+      allowedExperimentTypes: ['drug-response', 'metabolomics'],
+      limit: 10,
+    })
+
+    await hook.fetch()
+
+    expect(recordedUrls).toHaveLength(2)
+    expect(recordedUrls[0]).toContain('experiment_type=drug-response')
+    expect(recordedUrls[1]).toContain('experiment_type=metabolomics')
+    expect(hook.experiments.value.map(item => item.id)).toEqual([2, 1])
+    expect(hook.total.value).toBe(2)
+  })
+
+  it('filters experiment type options to the allowed platform scope', async () => {
+    vi.spyOn(useApi().client, 'get').mockImplementation(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      if (url.includes('experiment-types')) {
+        return {
+          data: [
+            { value: 'drug-response', label: 'Drug Response', color: '#0EA5E9' },
+            { value: 'proteomics', label: 'Proteomics', color: '#22C55E' },
+          ],
+        }
+      }
+      if (url.includes('projects')) {
+        return { data: { projects: [], total: 0 } }
+      }
+      return { data: fakeResponse }
+    })
+
+    const hook = useExperimentSelector({
+      allowedExperimentTypes: ['drug-response'],
+    })
+
+    await hook.fetchFilterOptions()
+
+    expect(hook.experimentTypes.value).toEqual([
+      { value: 'drug-response', label: 'Drug Response', color: '#0EA5E9' },
+    ])
+  })
+
+  it('loadMore appends the next page', async () => {
+    const hook = useExperimentSelector({ limit: 1 })
+
+    fakeResponse = { experiments: [experiment(1)], total: 2 }
+    await hook.fetch()
+    fakeResponse = { experiments: [experiment(2)], total: 2 }
+    await hook.loadMore()
+
+    expect(hook.experiments.value.map(item => item.id)).toEqual([1, 2])
+    expect(hook.page.value).toBe(1)
+    expect(recordedUrls[1]).toContain('skip=1')
+  })
+
+  it('sets error and clears first page results on failure', async () => {
+    fakeError = new Error('network down')
+    const hook = useExperimentSelector()
+
+    await hook.fetch()
+
+    expect(hook.error.value).toBe('network down')
+    expect(hook.experiments.value).toEqual([])
+    expect(hook.total.value).toBe(0)
+    expect(hook.lastLoadedAt.value).toBeNull()
+  })
+
+  it('clear resets selection, filters, sort, and errors', async () => {
+    const hook = useExperimentSelector()
+    hook.select(experiment(7))
+    hook.filters.search = 'drug'
+    hook.sortKey.value = 'name:asc'
+
+    fakeError = new Error('failed once')
+    await hook.fetch()
+    expect(hook.error.value).toBe('failed once')
+
+    hook.clear()
+
+    expect(hook.selectedExperiment.value).toBeNull()
+    expect(hook.filters.search).toBeUndefined()
+    expect(hook.sortKey.value).toBe('created_at:desc')
+    expect(hook.error.value).toBeNull()
+  })
+
+  it('debounces search filter fetches', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector()
+    await hook.fetch()
+
+    hook.filters.search = 'glu'
+    await nextTick()
+    hook.filters.search = 'glucose'
+    await nextTick()
+
+    await vi.advanceTimersByTimeAsync(299)
+    expect(recordedUrls).toHaveLength(1)
+
+    await vi.advanceTimersByTimeAsync(1)
+    expect(recordedUrls).toHaveLength(2)
+    expect(recordedUrls[1]).toContain('search=glucose')
+  })
+
+  it('cancels pending search debounce when discrete filters change', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector()
+    await hook.fetch()
+
+    hook.filters.search = 'pending'
+    await nextTick()
+    hook.filters.status = 'planned'
+    await nextTick()
+    await Promise.resolve()
+
+    expect(recordedUrls).toHaveLength(2)
+    expect(recordedUrls[1]).toContain('status=planned')
+
+    await vi.advanceTimersByTimeAsync(300)
+    expect(recordedUrls).toHaveLength(2)
+  })
+
+  it('does not let an older list response overwrite the latest filters', async () => {
+    vi.useFakeTimers()
+    const older = deferredResponse()
+    const newer = deferredResponse()
+    vi.spyOn(useApi().client, 'get')
+      .mockImplementationOnce(() => older.promise)
+      .mockImplementationOnce(() => newer.promise)
+    const hook = useExperimentSelector()
+
+    hook.filters.search = 'old'
+    const olderFetch = hook.fetch()
+    hook.filters.search = 'new'
+    const newerFetch = hook.fetch()
+
+    newer.resolve({
+      data: { experiments: [experiment(2, { name: 'New' })], total: 1 },
+    })
+    await newerFetch
+    older.resolve({
+      data: { experiments: [experiment(1, { name: 'Old' })], total: 1 },
+    })
+    await olderFetch
+
+    expect(hook.experiments.value.map(item => item.name)).toEqual(['New'])
+  })
+
+  it('invalidates an active request before a debounced search starts', async () => {
+    vi.useFakeTimers()
+    const older = deferredResponse()
+    vi.spyOn(useApi().client, 'get').mockImplementationOnce(() => older.promise)
+    const hook = useExperimentSelector()
+
+    const olderFetch = hook.fetch()
+    hook.filters.search = 'new'
+    await nextTick()
+    older.resolve({
+      data: { experiments: [experiment(1, { name: 'Old' })], total: 1 },
+    })
+    await olderFetch
+
+    expect(hook.experiments.value).toEqual([])
+  })
+
+  it('keeps loading true when a stale request finishes before the latest request', async () => {
+    vi.useFakeTimers()
+    const older = deferredResponse()
+    const newer = deferredResponse()
+    vi.spyOn(useApi().client, 'get')
+      .mockImplementationOnce(() => older.promise)
+      .mockImplementationOnce(() => newer.promise)
+    const hook = useExperimentSelector()
+
+    const olderFetch = hook.fetch()
+    const newerFetch = hook.fetch()
+    older.resolve({ data: { experiments: [experiment(1)], total: 1 } })
+    await olderFetch
+
+    expect(hook.isLoading.value).toBe(true)
+
+    newer.resolve({ data: { experiments: [experiment(2)], total: 1 } })
+    await newerFetch
+  })
+})

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

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  detectDelimiter,
+  parseDelimitedText,
+  useFileImport,
+  validateImportFile,
+} from '../../composables/useFileImport'
+
+describe('file import helpers', () => {
+  it('parses quoted CSV fields', () => {
+    const parsed = parseDelimitedText('name,notes\nSample A,"hello, world"\n')
+
+    expect(parsed.delimiter).toBe(',')
+    expect(parsed.columns).toEqual(['name', 'notes'])
+    expect(parsed.rows).toEqual([{ name: 'Sample A', notes: 'hello, world' }])
+  })
+
+  it('detects TSV data', () => {
+    expect(detectDelimiter('name\tvalue\nA\t1')).toBe('\t')
+  })
+
+  it('validates accepted extensions and size', () => {
+    const file = new File(['abc'], 'plate.csv', { type: 'text/csv' })
+
+    expect(() => validateImportFile(file, { accept: '.csv', maxSizeBytes: 10 })).not.toThrow()
+    expect(() => validateImportFile(file, { accept: '.xlsx' })).toThrow('Unsupported file type')
+    expect(() => validateImportFile(file, { maxSizeBytes: 1 })).toThrow('File is too large')
+  })
+
+  it('reads and parses a file through useFileImport', async () => {
+    const file = new File(['name\nA\n'], 'samples.csv', { type: 'text/csv' })
+    const importer = useFileImport({
+      accept: '.csv',
+      parse: text => parseDelimitedText(text),
+    })
+
+    const result = await importer.importFile(file)
+
+    expect(importer.fileName.value).toBe('samples.csv')
+    expect(result.rows).toEqual([{ name: 'A' }])
+    expect(importer.loading.value).toBe(false)
+  })
+})

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

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi } from 'vitest'
+import { nextTick, reactive } from 'vue'
+
+// Mock vue lifecycle hooks since we're not in a component
+vi.mock('vue', async () => {
+  const actual = await vi.importActual('vue')
+  return {
+    ...actual,
+    onMounted: vi.fn(),
+    onUnmounted: vi.fn(),
+  }
+})
+
+import { useForm } from '../../composables/useForm'
+
+describe('useForm', () => {
+  describe('initialization', () => {
+    it('should initialize with provided values', () => {
+      const { data } = useForm({ name: '', email: '' })
+      expect(data.name).toBe('')
+      expect(data.email).toBe('')
+    })
+
+    it('should unwrap nested reactive initial values before cloning', () => {
+      const initial = reactive({
+        sampleNames: ['Vehicle', 'Drug'],
+        metadata: { groups: ['Control'] },
+      })
+
+      const { data, reset } = useForm(initial)
+
+      expect(data.sampleNames).toEqual(['Vehicle', 'Drug'])
+      expect(data.metadata.groups).toEqual(['Control'])
+
+      data.sampleNames.push('Rescue')
+      data.metadata.groups.push('Treatment')
+      reset()
+
+      expect(data.sampleNames).toEqual(['Vehicle', 'Drug'])
+      expect(data.metadata.groups).toEqual(['Control'])
+    })
+
+    it('should start with no errors', () => {
+      const { errors } = useForm({ name: '' })
+      expect(errors.name).toBeNull()
+    })
+
+    it('should start as not dirty', () => {
+      const { isDirty } = useForm({ name: '' })
+      expect(isDirty.value).toBe(false)
+    })
+  })
+
+  describe('validation - required', () => {
+    it('should fail for empty required field', () => {
+      const { validateField, errors } = useForm(
+        { name: '' },
+        { name: { required: true } }
+      )
+      const valid = validateField('name')
+      expect(valid).toBe(false)
+      expect(errors.name).toBe('This field is required')
+    })
+
+    it('should pass for filled required field', () => {
+      const { data, validateField, errors } = useForm(
+        { name: '' },
+        { name: { required: true } }
+      )
+      data.name = 'Alice'
+      const valid = validateField('name')
+      expect(valid).toBe(true)
+      expect(errors.name).toBeNull()
+    })
+
+    it('should use custom required message', () => {
+      const { validateField, errors } = useForm(
+        { name: '' },
+        { name: { required: 'Name is required' } }
+      )
+      validateField('name')
+      expect(errors.name).toBe('Name is required')
+    })
+  })
+
+  describe('validation - email', () => {
+    it('should reject invalid email', () => {
+      const { data, validateField, errors } = useForm(
+        { email: '' },
+        { email: { email: true } }
+      )
+      data.email = 'notanemail'
+      const valid = validateField('email')
+      expect(valid).toBe(false)
+      expect(errors.email).toBe('Invalid email address')
+    })
+
+    it('should accept valid email', () => {
+      const { data, validateField, errors } = useForm(
+        { email: '' },
+        { email: { email: true } }
+      )
+      data.email = 'user@example.com'
+      const valid = validateField('email')
+      expect(valid).toBe(true)
+      expect(errors.email).toBeNull()
+    })
+  })
+
+  describe('validation - minLength', () => {
+    it('should reject short strings', () => {
+      const { data, validateField, errors } = useForm(
+        { password: '' },
+        { password: { minLength: 8 } }
+      )
+      data.password = 'abc'
+      const valid = validateField('password')
+      expect(valid).toBe(false)
+      expect(errors.password).toBe('Must be at least 8 characters')
+    })
+  })
+
+  describe('validation - pattern', () => {
+    it('should validate with regex', () => {
+      const { data, validateField, errors } = useForm(
+        { code: '' },
+        { code: { pattern: /^[A-Z]{3}$/ } }
+      )
+      data.code = 'ab'
+      expect(validateField('code')).toBe(false)
+      expect(errors.code).toBe('Invalid format')
+
+      data.code = 'ABC'
+      expect(validateField('code')).toBe(true)
+    })
+  })
+
+  describe('validation - custom', () => {
+    it('should support custom validator', () => {
+      const { data, validateField, errors } = useForm(
+        { password: '', confirm: '' },
+        {
+          confirm: {
+            custom: (value, formData) =>
+              value !== formData.password ? 'Passwords must match' : undefined,
+          },
+        }
+      )
+      data.password = 'secret123'
+      data.confirm = 'different'
+      expect(validateField('confirm')).toBe(false)
+      expect(errors.confirm).toBe('Passwords must match')
+
+      data.confirm = 'secret123'
+      expect(validateField('confirm')).toBe(true)
+    })
+  })
+
+  describe('validate (all fields)', () => {
+    it('should validate all fields at once', () => {
+      const { validate, errors } = useForm(
+        { name: '', email: '' },
+        { name: { required: true }, email: { required: true } }
+      )
+      const valid = validate()
+      expect(valid).toBe(false)
+      expect(errors.name).not.toBeNull()
+      expect(errors.email).not.toBeNull()
+    })
+  })
+
+  describe('setFieldValue', () => {
+    it('should update field value', () => {
+      const { data, setFieldValue } = useForm({ name: '' })
+      setFieldValue('name', 'Bob')
+      expect(data.name).toBe('Bob')
+    })
+  })
+
+  describe('reset', () => {
+    it('should reset to initial values', () => {
+      const { data, errors, touched, dirty, reset, setFieldTouched } = useForm(
+        { name: 'initial' },
+        { name: { required: true } }
+      )
+      data.name = 'changed'
+      setFieldTouched('name')
+      reset()
+      expect(data.name).toBe('initial')
+      expect(errors.name).toBeNull()
+      expect(touched.name).toBe(false)
+      expect(dirty.name).toBe(false)
+    })
+  })
+
+  describe('replaceState', () => {
+    it('should replace values and clear field state', async () => {
+      const { data, errors, touched, dirty, isDirty, replaceState, setFieldTouched } = useForm<Record<string, unknown>>(
+        { name: 'initial', stale: 'remove' },
+        { name: { required: true } }
+      )
+
+      data.name = ''
+      setFieldTouched('name')
+      expect(errors.name).toBe('This field is required')
+
+      replaceState({ name: 'server', added: 3 })
+      await nextTick()
+
+      expect(data.name).toBe('server')
+      expect(data.stale).toBeUndefined()
+      expect(data.added).toBe(3)
+      expect(errors.name).toBeNull()
+      expect(errors.stale).toBeUndefined()
+      expect(touched.name).toBe(false)
+      expect(dirty.name).toBe(false)
+      expect(isDirty.value).toBe(false)
+    })
+
+    it('should use replaced values as the next reset baseline', () => {
+      const { data, replaceState, reset } = useForm<Record<string, unknown>>({
+        samples: ['Vehicle'],
+      })
+      const loaded = reactive({ samples: ['Drug'] })
+
+      replaceState(loaded)
+      ;(data.samples as string[]).push('Rescue')
+      reset()
+
+      expect(data.samples).toEqual(['Drug'])
+    })
+  })
+
+  describe('dirty tracking', () => {
+    it('should track dirty state on setFieldValue', () => {
+      const { setFieldValue } = useForm({ name: 'original' })
+      setFieldValue('name', 'changed')
+      // Note: dirty tracking happens via watch, which may be async in tests
+      // setFieldValue directly mutates data, watch triggers next tick
+    })
+  })
+
+  describe('handleSubmit', () => {
+    it('should call onSubmit when valid', async () => {
+      const onSubmit = vi.fn()
+      const { data, handleSubmit } = useForm({ name: 'Alice' })
+      const handler = handleSubmit(onSubmit)
+      await handler()
+      expect(onSubmit).toHaveBeenCalledWith(data)
+    })
+
+    it('should not call onSubmit when invalid', async () => {
+      const onSubmit = vi.fn()
+      const { handleSubmit } = useForm(
+        { name: '' },
+        { name: { required: true } }
+      )
+      const handler = handleSubmit(onSubmit)
+      await handler()
+      expect(onSubmit).not.toHaveBeenCalled()
+    })
+  })
+})