@morscherlab/mint-sdk 1.0.0-beta.7 → 1.0.0-rc.2

package/src/composables/experimentDesignData.ts

@@ -0,0 +1,182 @@
+import type { SelectOption } from '../types'
+
+export interface ExperimentDesignDataResponse {
+  experiment_id?: number
+  plugin_id?: string
+  data?: Record<string, unknown>
+  schema_version?: string
+  updated_at?: string | null
+}
+
+export interface ExtractExperimentSamplesOptions {
+  includeControls?: boolean
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function isPlatformDesignDataResponse(value: Record<string, unknown>): boolean {
+  return (
+    'data' in value
+    && (
+      'experiment_id' in value
+      || 'plugin_id' in value
+      || 'schema_version' in value
+      || 'updated_at' in value
+    )
+  )
+}
+
+/** Return the plugin-defined design_data payload from common platform and plugin response shapes. */
+export function unwrapExperimentDesignData(
+  rawData: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | null {
+  if (!rawData) return null
+
+  if (isRecord(rawData.data) && isPlatformDesignDataResponse(rawData)) {
+    return rawData.data
+  }
+
+  if (isRecord(rawData.design_data)) {
+    return rawData.design_data
+  }
+
+  if (isRecord(rawData.designData)) {
+    return rawData.designData
+  }
+
+  return rawData
+}
+
+function shouldIncludeSample(record: Record<string, unknown>, options: ExtractExperimentSamplesOptions): boolean {
+  if (options.includeControls) return true
+  const rawType = record.sample_type ?? record.sampleType ?? record.type ?? record.well_type ?? record.wellType
+  const type = typeof rawType === 'string' ? rawType.toLowerCase() : ''
+  return !['blank', 'qc'].includes(type)
+}
+
+function readSampleValue(record: Record<string, unknown>): string | null {
+  const candidates = [
+    record.sample_name,
+    record.sampleName,
+    record.sample_id,
+    record.sampleId,
+    record.name,
+    record.id,
+    record.label,
+  ]
+
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return candidate
+    }
+    if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+      return String(candidate)
+    }
+  }
+
+  return null
+}
+
+function readSampleLabel(record: Record<string, unknown>, fallback: string): string {
+  const label = record.name ?? record.label ?? record.sample_name ?? record.sampleName
+  return typeof label === 'string' && label.trim() ? label : fallback
+}
+
+function readSampleDescription(record: Record<string, unknown>): string | undefined {
+  const parts = [
+    record.group,
+    record.batch,
+    record.batch_id,
+    record.batchId,
+    record.plate_id,
+    record.plateId,
+    record.well_id,
+    record.wellId,
+  ].filter((value): value is string | number =>
+    (typeof value === 'string' && value.trim().length > 0)
+    || typeof value === 'number',
+  )
+
+  return parts.length > 0 ? parts.map(String).join(' / ') : undefined
+}
+
+function addSampleRecord(
+  options: SelectOption<string>[],
+  seen: Set<string>,
+  value: unknown,
+  extractOptions: ExtractExperimentSamplesOptions,
+): void {
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed)
+      options.push({ value: trimmed, label: trimmed })
+    }
+    return
+  }
+
+  if (!isRecord(value) || !shouldIncludeSample(value, extractOptions)) return
+
+  const sampleValue = readSampleValue(value)
+  if (!sampleValue || seen.has(sampleValue)) return
+
+  seen.add(sampleValue)
+  options.push({
+    value: sampleValue,
+    label: readSampleLabel(value, sampleValue),
+    description: readSampleDescription(value),
+  })
+}
+
+function addSampleArray(
+  options: SelectOption<string>[],
+  seen: Set<string>,
+  value: unknown,
+  extractOptions: ExtractExperimentSamplesOptions,
+): void {
+  if (!Array.isArray(value)) return
+  for (const sample of value) {
+    addSampleRecord(options, seen, sample, extractOptions)
+  }
+}
+
+/** Extract selectable sample options from raw or wrapped experiment design_data. */
+export function extractSampleOptionsFromDesignData(
+  rawData: Record<string, unknown> | null | undefined,
+  options: ExtractExperimentSamplesOptions = {},
+): SelectOption<string>[] {
+  const designData = unwrapExperimentDesignData(rawData)
+  if (!designData) return []
+
+  const sampleOptions: SelectOption<string>[] = []
+  const seen = new Set<string>()
+
+  addSampleArray(sampleOptions, seen, designData.samples, options)
+
+  if (isRecord(designData.templates)) {
+    for (const template of Object.values(designData.templates)) {
+      if (!isRecord(template)) continue
+      const templateData = isRecord(template.data) ? template.data : template
+      addSampleArray(sampleOptions, seen, templateData.samples, options)
+    }
+  }
+
+  if (Array.isArray(designData.plates)) {
+    for (const plate of designData.plates) {
+      if (!isRecord(plate)) continue
+      addSampleArray(sampleOptions, seen, plate.samples, options)
+    }
+  }
+
+  return sampleOptions
+}
+
+/** Extract SampleSelector-compatible string values from raw or wrapped experiment design_data. */
+export function extractSampleNamesFromDesignData(
+  rawData: Record<string, unknown> | null | undefined,
+  options: ExtractExperimentSamplesOptions = {},
+): string[] {
+  return extractSampleOptionsFromDesignData(rawData, options).map(sample => sample.value)
+}

package/src/composables/index.ts

@@ -144,6 +144,20 @@ export {
   type UseExperimentDataOptions,
   type UseExperimentDataReturn,
 } from './useExperimentData'
+export {
+  extractSampleNamesFromDesignData,
+  extractSampleOptionsFromDesignData,
+  unwrapExperimentDesignData,
+  type ExperimentDesignDataResponse,
+  type ExtractExperimentSamplesOptions,
+} from './experimentDesignData'
+export {
+  useExperimentSamples,
+  type ExperimentDesignDataSource,
+  type ExperimentIdSource,
+  type UseExperimentSamplesOptions,
+  type UseExperimentSamplesReturn,
+} from './useExperimentSamples'
 export {
   getFieldRegistryEntry,
   getTypeDefault,

package/src/composables/useApi.ts

@@ -1,17 +1,97 @@
-import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios'
+import axios, { type AxiosInstance, type AxiosRequestConfig, type InternalAxiosRequestConfig } from 'axios'
 import { useSettingsStore } from '../stores/settings'
 import { useAuthStore } from '../stores/auth'
 
 let apiClientInstance: AxiosInstance | null = null
 let interceptorAttached = false
 
+interface MintAxiosRequestConfig extends AxiosRequestConfig {
+  _mintSkipAuth?: boolean
+}
+
+interface MintInternalAxiosRequestConfig extends InternalAxiosRequestConfig {
+  _mintSkipAuth?: boolean
+}
+
+type MutableHeaders = Record<string, unknown> & {
+  has?: (header: string) => boolean
+  set?: (header: string, value: string) => void
+  delete?: (header: string) => void
+}
+
 function joinUrlPath(baseUrl: string, path: string): string {
   if (!path) return baseUrl
+  if (path.startsWith('?') || path.startsWith('#')) return `${baseUrl.replace(/\/+$/, '')}${path}`
   const normalizedBase = baseUrl.replace(/\/+$/, '')
   const normalizedPath = path.replace(/^\/+/, '/')
   return `${normalizedBase}${normalizedPath.startsWith('/') ? normalizedPath : `/${normalizedPath}`}`
 }
 
+function getBasePath(baseUrl: string): string {
+  if (!baseUrl) return '/'
+
+  try {
+    const origin = typeof window !== 'undefined' ? window.location.origin : 'http://localhost'
+    return new URL(baseUrl, origin).pathname.replace(/\/+$/, '') || '/'
+  } catch {
+    const path = baseUrl.replace(/^https?:\/\/[^/]+/i, '')
+    return path.replace(/\/+$/, '') || '/'
+  }
+}
+
+function normalizeRequestUrl(baseUrl: string, url: string): string {
+  if (!url || /^https?:\/\//.test(url)) return url
+
+  const basePath = getBasePath(baseUrl)
+  if (basePath === '/') return url
+
+  const normalizedUrl = url.startsWith('/') ? url : `/${url}`
+  if (
+    normalizedUrl === basePath
+    || normalizedUrl.startsWith(`${basePath}?`)
+    || normalizedUrl.startsWith(`${basePath}#`)
+  ) {
+    return normalizedUrl.slice(basePath.length)
+  }
+  if (normalizedUrl.startsWith(`${basePath}/`)) {
+    return normalizedUrl.slice(basePath.length) || ''
+  }
+  return url
+}
+
+function asMutableHeaders(headers: AxiosRequestConfig['headers']): MutableHeaders | null {
+  return headers ? (headers as MutableHeaders) : null
+}
+
+function hasAuthorizationHeader(headers: AxiosRequestConfig['headers']): boolean {
+  const bag = asMutableHeaders(headers)
+  if (!bag) return false
+  if (typeof bag.has === 'function') return bag.has('Authorization')
+  return Object.keys(bag).some((key) => key.toLowerCase() === 'authorization')
+}
+
+function setAuthorizationHeader(headers: AxiosRequestConfig['headers'], value: string): void {
+  const bag = asMutableHeaders(headers)
+  if (!bag) return
+  if (typeof bag.set === 'function') {
+    bag.set('Authorization', value)
+    return
+  }
+  bag.Authorization = value
+}
+
+function deleteAuthorizationHeader(headers: AxiosRequestConfig['headers']): void {
+  const bag = asMutableHeaders(headers)
+  if (!bag) return
+  if (typeof bag.delete === 'function') {
+    bag.delete('Authorization')
+    return
+  }
+  for (const key of Object.keys(bag)) {
+    if (key.toLowerCase() === 'authorization') delete bag[key]
+  }
+}
+
 function getApiClient(): AxiosInstance {
   if (!apiClientInstance) {
     apiClientInstance = axios.create({
@@ -56,51 +136,68 @@ export function useApi(options: ApiClientOptions = {}): UseApiReturn {
   // Attach auth interceptor only once (reads token dynamically, not from closure)
   if (!interceptorAttached) {
     apiClient.interceptors.request.use((config) => {
-      if (authStore.token && config.headers && !config.headers.Authorization) {
-        config.headers.Authorization = `Bearer ${authStore.token}`
+      const request = config as MintInternalAxiosRequestConfig
+      if (request._mintSkipAuth) {
+        delete request._mintSkipAuth
+        deleteAuthorizationHeader(request.headers)
+        return request
+      }
+
+      const currentAuthStore = useAuthStore()
+      if (currentAuthStore.token && config.headers && !hasAuthorizationHeader(config.headers)) {
+        setAuthorizationHeader(config.headers, `Bearer ${currentAuthStore.token}`)
       }
       return config
     })
     interceptorAttached = true
   }
 
+  function getBaseUrl(): string {
+    return options.baseUrl ?? settingsStore.getApiBaseUrl()
+  }
+
+  function normalizeUrl(url: string): string {
+    return normalizeRequestUrl(getBaseUrl(), url)
+  }
+
   // Build per-request config that applies this caller's options
-  function requestConfig(config?: AxiosRequestConfig): AxiosRequestConfig {
-    const base: AxiosRequestConfig = {
-      baseURL: options.baseUrl ?? settingsStore.getApiBaseUrl(),
+  function requestConfig(config?: AxiosRequestConfig): MintAxiosRequestConfig {
+    const base: MintAxiosRequestConfig = {
+      baseURL: getBaseUrl(),
       timeout: options.timeout ?? settingsStore.requestTimeout,
       ...config,
     }
     // Strip auth header if explicitly disabled
     if (options.withAuth === false) {
-      base.headers = { ...base.headers, Authorization: undefined }
+      base._mintSkipAuth = true
+      deleteAuthorizationHeader(base.headers)
     }
     return base
   }
 
   // Generic request methods
   async function get<T>(url: string, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.get<T>(url, requestConfig(config))
+    const response = await apiClient.get<T>(normalizeUrl(url), requestConfig(config))
     return response.data
   }
 
   async function post<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.post<T>(url, data, requestConfig(config))
+    const response = await apiClient.post<T>(normalizeUrl(url), data, requestConfig(config))
     return response.data
   }
 
   async function put<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.put<T>(url, data, requestConfig(config))
+    const response = await apiClient.put<T>(normalizeUrl(url), data, requestConfig(config))
     return response.data
   }
 
   async function patch<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.patch<T>(url, data, requestConfig(config))
+    const response = await apiClient.patch<T>(normalizeUrl(url), data, requestConfig(config))
     return response.data
   }
 
   async function del<T>(url: string, config?: AxiosRequestConfig): Promise<T> {
-    const response = await apiClient.delete<T>(url, requestConfig(config))
+    const response = await apiClient.delete<T>(normalizeUrl(url), requestConfig(config))
     return response.data
   }
 
@@ -117,7 +214,7 @@ export function useApi(options: ApiClientOptions = {}): UseApiReturn {
       })
     }
 
-    const response = await apiClient.post<T>(url, formData, requestConfig({
+    const response = await apiClient.post<T>(normalizeUrl(url), formData, requestConfig({
       // Let Axios set Content-Type with the correct multipart boundary
       headers: { 'Content-Type': undefined },
     }))
@@ -126,7 +223,7 @@ export function useApi(options: ApiClientOptions = {}): UseApiReturn {
 
   // Download helper - returns blob URL
   async function download(url: string, filename?: string): Promise<string> {
-    const response = await apiClient.get(url, requestConfig({ responseType: 'blob' }))
+    const response = await apiClient.get(normalizeUrl(url), requestConfig({ responseType: 'blob' }))
     const blob = new Blob([response.data])
     const blobUrl = URL.createObjectURL(blob)
 
@@ -150,8 +247,8 @@ export function useApi(options: ApiClientOptions = {}): UseApiReturn {
 
   // Build full URL for external use (e.g., <a href="...">)
   function buildUrl(path: string): string {
-    const baseUrl = options.baseUrl ?? settingsStore.getApiBaseUrl()
-    return joinUrlPath(baseUrl, path)
+    const baseUrl = getBaseUrl()
+    return joinUrlPath(baseUrl, normalizeRequestUrl(baseUrl, path))
   }
 
   // WebSocket URL builder

package/src/composables/useAuth.ts

@@ -3,6 +3,7 @@ import { ref, onMounted, onUnmounted, watch, getCurrentInstance, type Ref } from
 import { useAuthStore } from '../stores/auth'
 import { useSettingsStore } from '../stores/settings'
 import type { AuthConfig, UserInfo, LoginResponse, TokenVerifyResponse, UpdateProfileRequest } from '../types'
+import type { RoleInfo } from '../permissions'
 
 interface UserResponse {
   id: string
@@ -10,6 +11,7 @@ interface UserResponse {
   shortname: string | null
   email: string | null
   role: string
+  role_obj?: RoleInfo | null
   is_active: boolean
 }
 
@@ -187,6 +189,7 @@ export function useAuth(): UseAuthReturn {
         shortname: response.data.shortname,
         email: response.data.email,
         role: response.data.role,
+        roleObj: response.data.role_obj ?? null,
         isActive: response.data.is_active,
       }
 
@@ -379,6 +382,7 @@ export function useAuth(): UseAuthReturn {
         shortname: response.data.shortname,
         email: response.data.email,
         role: response.data.role,
+        roleObj: response.data.role_obj ?? null,
         isActive: response.data.is_active,
       }
       authStore.setUserInfo(userInfo)

package/src/composables/useAutoGroup.ts

@@ -9,6 +9,7 @@ import type {
   ParsedCsvData,
 } from '../types/auto-group'
 import type { SampleGroup } from '../types/components'
+import { unwrapExperimentDesignData } from './experimentDesignData'
 
 export const DEFAULT_COLORS = [
   '#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6',
@@ -254,10 +255,12 @@ export function computeGroups(
     }
     const groupKey = keyParts.join(' / ')
 
-    if (!groupMap.has(groupKey)) {
-      groupMap.set(groupKey, [])
+    const group = groupMap.get(groupKey)
+    if (group) {
+      group.push(sample)
+    } else {
+      groupMap.set(groupKey, [sample])
     }
-    groupMap.get(groupKey)!.push(sample)
 
     // Build metadata row with ALL columns
     const fields: Record<string, string> = {}
@@ -309,7 +312,10 @@ export function computeGroups(
 export function extractSamplesFromDesignData(
   rawData: Record<string, unknown>,
 ): ParsedCsvData | null {
-  const samples = rawData.samples
+  const designData = unwrapExperimentDesignData(rawData)
+  if (!designData) return null
+
+  const samples = designData.samples
   if (!Array.isArray(samples) || samples.length === 0) return null
 
   // Single pass: filter QC/blank and collect all condition keys
@@ -369,10 +375,12 @@ export function computeGroupsFromCsv(
     const keyParts = enabledCols.map(col => row[col.originalName ?? col.name])
     const groupKey = keyParts.join(' / ')
 
-    if (!groupMap.has(groupKey)) {
-      groupMap.set(groupKey, [])
+    const group = groupMap.get(groupKey)
+    if (group) {
+      group.push(sampleName)
+    } else {
+      groupMap.set(groupKey, [sampleName])
     }
-    groupMap.get(groupKey)!.push(sampleName)
 
     // Build metadata row with ALL columns — use display name as key, original for lookup
     const fields: Record<string, string> = {}
@@ -417,8 +425,9 @@ export function useAutoGroup() {
   )
 
   const samples = computed(() => {
-    if (isTabularMode.value && csvData.value) {
-      return csvData.value.rows.map(r => r[csvData.value!.sampleColumn])
+    const data = csvData.value
+    if (isTabularMode.value && data) {
+      return data.rows.map(r => r[data.sampleColumn])
     }
     return rawText.value
       .split('\n')

package/src/composables/useControlSchema.ts

@@ -6,6 +6,7 @@ import type {
   SettingsModalSchema,
   TopBarSettingsConfig,
 } from '../types'
+import type { AccessPolicy, AccessAudienceInput } from '../permissions'
 import type {
   FieldCondition,
   FieldValidation,
@@ -34,6 +35,11 @@ export interface ControlSectionConfig {
   iconBg?: string
   columns?: 1 | 2 | 3
   condition?: FieldCondition
+  access?: AccessPolicy
+  visibleFor?: AccessAudienceInput
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
   defaultOpen?: boolean
   showToggle?: boolean
 }
@@ -70,6 +76,11 @@ export interface ControlDefinition {
   pattern?: string | { value: string; message: string }
   validation?: FieldValidation
   condition?: FieldCondition
+  access?: AccessPolicy
+  visibleFor?: AccessAudienceInput
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
   options?: readonly ControlOption[]
   section?: string
   sectionLabel?: string
@@ -760,6 +771,11 @@ export function controlsToSettingsSchema(
         fields: sectionControls.map(controlToFormField),
         columns: config.columns ?? options.columns ?? 1,
         condition: config.condition,
+        access: config.access,
+        visibleFor: config.visibleFor,
+        requiresAdmin: config.requiresAdmin,
+        permissions: config.permissions,
+        anyPermissions: config.anyPermissions,
       }
     }),
   }
@@ -1150,6 +1166,11 @@ function controlToFormField(control: NormalizedControl): FormFieldSchema {
     readonly: definition.readonly,
     validation: validationForControl(definition),
     condition: definition.condition,
+    access: definition.access,
+    visibleFor: definition.visibleFor,
+    requiresAdmin: definition.requiresAdmin,
+    permissions: definition.permissions,
+    anyPermissions: definition.anyPermissions,
     colSpan: definition.colSpan,
     props,
   }