@morscherlab/mint-sdk 1.3.11 → 1.4.0-beta.10

package/src/composables/useExperimentSelector.ts

@@ -1,7 +1,7 @@
 import { ref, reactive, computed, watch, type Ref, type ComputedRef } from 'vue'
 import { useApi } from './useApi'
 import { useDebouncedWatch } from './useDebouncedWatch'
-import { useRequestSyncState } from './useRequestSyncState'
+import { useRequest } from './useRequest'
 import { datePresetToISO } from './experiment-utils'
 import type {
   ExperimentSummary,
@@ -28,6 +28,8 @@ export interface UseExperimentSelectorOptions {
   apiBaseUrl?: string
   limit?: number
   immediate?: boolean
+  /** Keep `statusCounts` in step with the non-status filters (one stats request per change). */
+  withStatusCounts?: boolean
 }
 
 export interface UseExperimentSelectorReturn {
@@ -57,9 +59,8 @@ export interface UseExperimentSelectorReturn {
   experimentTypes: Ref<ExperimentTypeOption[]>
   /** Available project options for filter UI. */
   projects: Ref<SelectOption<string>[]>
-  // Grouped view
-  /** Fetched experiments grouped by project name. */
-  groupedByProject: ComputedRef<[string, ExperimentSummary[]][]>
+  /** Experiment count per status under every filter except status itself. */
+  statusCounts: Ref<Record<string, number>>
   // Methods
   /** Fetch the current page with the current filters. */
   fetch: () => Promise<void>
@@ -73,6 +74,8 @@ export interface UseExperimentSelectorReturn {
   clear: () => void
   /** Fetch experiment type and project filter options. */
   fetchFilterOptions: () => Promise<void>
+  /** Fetch `statusCounts` from `GET /experiments/stats`. */
+  fetchStatusCounts: () => Promise<void>
 }
 
 /** Fetches a paginated, filtered experiment list from the platform API for picker and selector UIs. */
@@ -85,6 +88,7 @@ export function useExperimentSelector(
     experimentType,
     allowedExperimentTypes: optionAllowedExperimentTypes,
     apiBaseUrl,
+    withStatusCounts = false,
   } = options
   const platformBase = apiBaseUrl ?? getPlatformApiUrl()
   const api = useApi()
@@ -92,10 +96,10 @@ export function useExperimentSelector(
   const experiments = ref<ExperimentSummary[]>([])
   const total = ref(0)
   const selectedExperiment = ref<ExperimentSummary | null>(null)
-  const request = useRequestSyncState('Failed to fetch experiments')
-  const isLoading = request.loading
+  const request = useRequest('Failed to fetch experiments')
+  const isLoading = request.isLoading
   const error = request.error
-  const lastLoadedAt = request.lastLoadedAt
+  const lastLoadedAt = ref<Date | null>(null)
   const page = ref(0)
   let fetchGeneration = 0
 
@@ -107,6 +111,10 @@ export function useExperimentSelector(
   const projects = ref<SelectOption<string>[]>([])
   let filterOptionsFetched = false
 
+  const statusCounts = ref<Record<string, number>>({})
+  let statsGeneration = 0
+  let countedScope: string | null = null
+
   const hasMore = computed(() => experiments.value.length < total.value)
 
   const filters: ExperimentFilters = reactive({
@@ -115,6 +123,7 @@ export function useExperimentSelector(
     project: undefined,
     experimentType: undefined,
     datePreset: undefined,
+    mine: undefined,
   })
 
   function normalizeExperimentTypes(values: string[] | null | undefined): string[] | null {
@@ -163,21 +172,27 @@ export function useExperimentSelector(
     return { kind: 'all' }
   }
 
-  function buildExperimentListUrl(typeFilter: string | undefined, skip: number, pageLimit: number): string {
+  /** Query params shared by the list and the stats route; status, sort and paging are list-only. */
+  function scopeParams(typeFilter: string | undefined): URLSearchParams {
     const params = new URLSearchParams()
     if (typeFilter) params.set('experiment_type', typeFilter)
-    if (filters.status) params.set('status', filters.status)
     if (filters.search) params.set('search', filters.search)
     if (filters.project) params.set('project', filters.project)
+    if (filters.mine) params.set('mine', 'true')
+    if (filters.datePreset) {
+      params.set('created_after', datePresetToISO(filters.datePreset))
+    }
+    return params
+  }
+
+  function buildExperimentListUrl(typeFilter: string | undefined, skip: number, pageLimit: number): string {
+    const params = scopeParams(typeFilter)
+    if (filters.status) params.set('status', filters.status)
 
     const { sortBy, sortOrder } = parseSortKey()
     params.set('sort_by', sortBy)
     params.set('sort_order', sortOrder)
 
-    if (filters.datePreset) {
-      params.set('created_after', datePresetToISO(filters.datePreset))
-    }
-
     params.set('limit', String(pageLimit))
     params.set('skip', String(skip))
 
@@ -245,7 +260,7 @@ export function useExperimentSelector(
         experiments.value = [...experiments.value, ...data.experiments]
       }
       total.value = data.total
-      request.markLoaded()
+      lastLoadedAt.value = new Date()
     } catch (err) {
       if (generation !== fetchGeneration) return
       request.setError(err, 'Failed to fetch experiments')
@@ -298,6 +313,51 @@ export function useExperimentSelector(
     }
   }
 
+  /** The filters the stats route reads; status, sort and paging do not change the counts. */
+  function countScope(): string {
+    return JSON.stringify([filters.search, filters.project, filters.experimentType, filters.datePreset, filters.mine])
+  }
+
+  function refreshStatusCountsOnScopeChange(): void {
+    if (withStatusCounts && countScope() !== countedScope) fetchStatusCounts()
+  }
+
+  async function fetchStatusCounts(): Promise<void> {
+    const generation = ++statsGeneration
+    countedScope = countScope()
+    const scope = resolveExperimentTypeScope()
+    if (scope.kind === 'blocked') {
+      statusCounts.value = {}
+      return
+    }
+    const types = scope.kind === 'multi'
+      ? scope.experimentTypes
+      : [scope.kind === 'single' ? scope.experimentType : undefined]
+    const base = platformBase ?? ''
+    try {
+      const responses = await Promise.all(
+        types.map(type => api.get<{ total: number; by_status: Record<string, number> }>(
+          `${base}/experiments/stats?${scopeParams(type)}`,
+        )),
+      )
+      if (generation !== statsGeneration) return
+      const counts: Record<string, number> = {}
+      for (const response of responses) {
+        for (const [status, count] of Object.entries(response.by_status)) {
+          counts[status] = (counts[status] ?? 0) + count
+        }
+      }
+      statusCounts.value = counts
+    } catch {
+      // Counts only decorate the status menu; without them it shows bare labels.
+      // Forget the scope so the next status or sort change retries the request.
+      if (generation === statsGeneration) {
+        statusCounts.value = {}
+        countedScope = null
+      }
+    }
+  }
+
   async function loadMore(): Promise<void> {
     if (!hasMore.value || isLoading.value) return
     page.value++
@@ -323,31 +383,12 @@ export function useExperimentSelector(
     filters.project = undefined
     filters.experimentType = undefined
     filters.datePreset = undefined
+    filters.mine = undefined
     sortKey.value = 'created_at:desc'
     page.value = 0
     request.clearError()
   }
 
-  // Group experiments by project (client-side)
-  const groupedByProject = computed<[string, ExperimentSummary[]][]>(() => {
-    const groups = new Map<string, ExperimentSummary[]>()
-    for (const exp of experiments.value) {
-      const key = exp.project_name ?? exp.project ?? 'No project'
-      const list = groups.get(key)
-      if (list) {
-        list.push(exp)
-      } else {
-        groups.set(key, [exp])
-      }
-    }
-    // Sort alphabetically, "No project" last
-    return [...groups.entries()].sort(([a], [b]) => {
-      if (a === 'No project') return 1
-      if (b === 'No project') return -1
-      return a.localeCompare(b)
-    })
-  })
-
   watch(
     () => [
       filters.search,
@@ -355,6 +396,7 @@ export function useExperimentSelector(
       filters.project,
       filters.experimentType,
       filters.datePreset,
+      filters.mine,
       sortKey.value,
     ],
     () => invalidateFetch(),
@@ -366,17 +408,20 @@ export function useExperimentSelector(
     () => {
       page.value = 0
       fetchExperiments()
+      refreshStatusCountsOnScopeChange()
     },
     { delay: 300 },
   )
 
   // Immediate watch on discrete filters and sort (cancel any pending search debounce)
   watch(
-    () => [filters.status, filters.project, filters.experimentType, filters.datePreset, sortKey.value],
+    () => [filters.status, filters.project, filters.experimentType, filters.datePreset, filters.mine, sortKey.value],
     () => {
       searchWatch.cancel()
       page.value = 0
       fetchExperiments()
+      // Also checked on a status or sort change: the cancelled debounce may hold a new search.
+      refreshStatusCountsOnScopeChange()
     },
   )
 
@@ -397,12 +442,13 @@ export function useExperimentSelector(
     sortKey,
     experimentTypes,
     projects,
-    groupedByProject,
+    statusCounts,
     fetch: fetchExperiments,
     loadMore,
     reset,
     select,
     clear,
     fetchFilterOptions,
+    fetchStatusCounts,
   }
 }

package/src/composables/useFileBrowser.ts

@@ -19,9 +19,10 @@ import type {
   FileSelection,
   ServerMount,
 } from '../types/fileBrowserTypes'
+import { MintApiError } from '../apiErrors'
 import { useApi } from './useApi'
 import { getInjectedPlatformContext } from './platformContextHelpers'
-import { useRequestSyncState } from './useRequestSyncState'
+import { useRequest } from './useRequest'
 
 export interface UseFileBrowserOptions {
   /** Extensions the caller cares about; entries are flagged, never removed. */
@@ -78,7 +79,7 @@ export interface UseFileBrowserReturn {
 export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrowserReturn {
   const injectedContext = getInjectedPlatformContext()
   const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl })
-  const sync = useRequestSyncState('Could not read the server mounts.')
+  const sync = useRequest('Could not read the server mounts.')
 
   const mounts = ref<ServerMount[]>([])
   const mountId = shallowRef('')
@@ -121,18 +122,12 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
     return rules.map((rule) => `&type_rules=${encodeURIComponent(rule)}`).join('')
   }
 
-  /** Prefer the API's own `detail` over axios's "Request failed with status N". */
-  function describe(cause: unknown, fallback: string): string {
-    const detail = (cause as { response?: { data?: { detail?: unknown } } })?.response?.data?.detail
-    return typeof detail === 'string' && detail ? detail : sync.readErrorMessage(cause, fallback)
-  }
-
   function fail(cause: unknown, fallback: string): void {
-    sync.setError(new Error(describe(cause, fallback)), fallback)
+    sync.setError(new Error(sync.readErrorMessage(cause, fallback)), fallback)
   }
 
   function statusOf(cause: unknown): number | undefined {
-    return (cause as { response?: { status?: number } })?.response?.status
+    return cause instanceof MintApiError ? cause.status : undefined
   }
 
   async function loadMounts(): Promise<boolean> {
@@ -147,7 +142,6 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
       if (disposed || token !== mountsToken) return false
       mounts.value = data.mounts ?? []
       sync.clearError()
-      sync.markLoaded()
       return true
     } catch (cause) {
       if (disposed || token !== mountsToken) return false
@@ -156,7 +150,6 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
       if (statusOf(cause) === 404) {
         mounts.value = []
         sync.clearError()
-        sync.markLoaded()
         return true
       }
       mounts.value = []
@@ -201,7 +194,6 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
       truncated.value = listing.truncated ?? false
       listingReady.value = true
       sync.clearError()
-      sync.markLoaded()
     } catch (cause) {
       if (disposed || token !== listToken) return
       entries.value = []

package/src/composables/useFilePicker.ts

@@ -8,7 +8,7 @@ import type {
   PickerSort,
   PickerSource,
 } from '../types/filePicker'
-import type { SegmentedOption } from '../types'
+import type { OptionPrimitive, SelectOption } from '../types'
 import { usePickerNavigation } from './filePicker/usePickerNavigation'
 import { usePickerSelection } from './filePicker/usePickerSelection'
 import { localFilesAdapter } from './filePicker/localFiles'
@@ -78,7 +78,7 @@ export function useFilePicker(
   const mountView = computed(
     () => source.value === 'server' && !!props.adapter.mounts && mounts.value.length > 0,
   )
-  const segments = computed<SegmentedOption[]>(() =>
+  const segments = computed<SelectOption<OptionPrimitive>[]>(() =>
     allowedSources.value.flatMap((item) =>
       item === 'server' && props.adapter.mounts && mounts.value.length
         ? mounts.value.map((mount) => ({

package/src/composables/useFormBuilder.ts

@@ -107,10 +107,9 @@ export function useFormBuilder<T extends Record<string, unknown> = Record<string
     }
     merged.onBlur = formProps.onBlur
 
-    // Error as boolean for components that use boolean error prop
-    const errorMsg = formProps.error
-    if (errorMsg) {
-      merged.error = true
+    // A field with an error message renders its control as invalid
+    if (formProps.error) {
+      merged.invalid = true
     }
 
     // Schema-level props

package/src/composables/useJobCenter.ts

@@ -0,0 +1,324 @@
+import {
+  computed,
+  onMounted,
+  onUnmounted,
+  ref,
+  shallowRef,
+  toValue,
+  type ComputedRef,
+  type MaybeRefOrGetter,
+  type Ref,
+  type ShallowRef,
+} from 'vue'
+
+import { isActiveJobStatus, normalizeJobState } from '../jobs'
+import type {
+  JobListPayload,
+  JobState,
+  JobStateInput,
+} from '../types/jobs'
+
+export type JobsStatusTrayTab = 'active' | 'history'
+
+/**
+ * The canonical owner of a collection of plugin jobs.
+ *
+ * Sources, rather than job-center UI, own polling, event streams, and all job
+ * mutations. This keeps components and consumers on one reactive job graph.
+ */
+export interface PluginJobCenterSource {
+  jobs: MaybeRefOrGetter<readonly JobStateInput[]>
+  refresh?: () => Promise<JobListPayload | readonly JobStateInput[] | void>
+  cancel?: (jobId: string) => Promise<JobStateInput | void>
+  delete?: (jobId: string) => Promise<boolean | void>
+  clear?: () => Promise<number | void>
+  dispose?: () => void
+}
+
+export interface CombinedPluginJobCenterSource extends PluginJobCenterSource {
+  jobs: ComputedRef<readonly JobStateInput[]>
+}
+
+/**
+ * Combines independent job runtimes without copying their reactive state.
+ *
+ * Job ids must be globally unique across the sources. A duplicate id throws
+ * when jobs are read or an id-routed action is requested, rather than silently
+ * dispatching a mutation to the wrong owner.
+ */
+export function combinePluginJobSources(
+  sources: readonly PluginJobCenterSource[],
+): CombinedPluginJobCenterSource {
+  const jobs = computed<readonly JobStateInput[]>(() => {
+    const combined: JobStateInput[] = []
+    const owners = new Set<string>()
+    for (const source of sources) {
+      for (const job of toValue(source.jobs)) {
+        if (owners.has(job.job_id)) throw duplicatePluginJobId(job.job_id)
+        owners.add(job.job_id)
+        combined.push(job)
+      }
+    }
+    return combined
+  })
+
+  function ownerFor(jobId: string): PluginJobCenterSource {
+    let owner: PluginJobCenterSource | undefined
+    for (const source of sources) {
+      if (!toValue(source.jobs).some(job => job.job_id === jobId)) continue
+      if (owner) throw duplicatePluginJobId(jobId)
+      owner = source
+    }
+    if (!owner) throw new Error(`Unknown plugin job id: ${jobId}`)
+    return owner
+  }
+
+  const combined: CombinedPluginJobCenterSource = { jobs }
+  if (sources.some(source => source.refresh)) {
+    combined.refresh = async () => {
+      await Promise.all(sources.map(source => source.refresh?.()))
+      return jobs.value
+    }
+  }
+  if (sources.some(source => source.cancel)) {
+    combined.cancel = async (jobId) => {
+      const owner = ownerFor(jobId)
+      if (!owner.cancel) throw new Error(`Job ${jobId} cannot be cancelled by its source`)
+      return owner.cancel(jobId)
+    }
+  }
+  if (sources.length > 0 && sources.every(source => source.delete)) {
+    combined.delete = async (jobId) => {
+      const owner = ownerFor(jobId)
+      if (!owner.delete) throw new Error(`Job ${jobId} cannot be deleted by its source`)
+      return owner.delete(jobId)
+    }
+  }
+  // Never report a successful combined clear after mutating only a subset.
+  // Without bulk support from every source, the job center can still fall
+  // back to this source's id-routed delete method when all owners expose it.
+  if (sources.length > 0 && sources.every(source => source.clear)) {
+    combined.clear = async () => {
+      const results = await Promise.all(
+        sources.map(source => source.clear!()),
+      )
+      return results.every((result): result is number => typeof result === 'number')
+        ? results.reduce((total, result) => total + result, 0)
+        : undefined
+    }
+  }
+  if (sources.some(source => source.dispose)) {
+    combined.dispose = () => {
+      const errors: unknown[] = []
+      for (const source of sources) {
+        try {
+          source.dispose?.()
+        } catch (cause) {
+          errors.push(cause)
+        }
+      }
+      if (errors.length === 1) throw errors[0]
+      if (errors.length > 1) throw new PluginJobSourceDisposeError(errors)
+    }
+  }
+  return combined
+}
+
+class PluginJobSourceDisposeError extends Error {
+  readonly cause: unknown
+  readonly errors: readonly unknown[]
+
+  constructor(errors: readonly unknown[]) {
+    super('Failed to dispose plugin job sources')
+    this.name = 'PluginJobSourceDisposeError'
+    this.cause = errors[0]
+    this.errors = Object.freeze([...errors])
+  }
+}
+
+function duplicatePluginJobId(jobId: string): Error {
+  return new Error(`Duplicate plugin job id across combined sources: ${jobId}`)
+}
+
+export interface UseJobCenterOptions {
+  source?: MaybeRefOrGetter<PluginJobCenterSource | undefined>
+  loadOnMount?: boolean
+}
+
+export interface UseJobCenterReturn {
+  jobs: ComputedRef<JobState[]>
+  activeJobs: ComputedRef<JobState[]>
+  historyJobs: ComputedRef<JobState[]>
+  deletableJobs: ComputedRef<JobState[]>
+  featuredJob: ComputedRef<JobState | null>
+  canRefresh: ComputedRef<boolean>
+  canCancel: ComputedRef<boolean>
+  canDelete: ComputedRef<boolean>
+  canClearFinished: ComputedRef<boolean>
+  isOpen: Ref<boolean>
+  activeTab: Ref<JobsStatusTrayTab>
+  isLoading: Ref<boolean>
+  error: ShallowRef<string | null>
+  pendingJobIds: Ref<Set<string>>
+  open: () => void
+  close: () => void
+  toggle: () => void
+  refresh: () => Promise<boolean>
+  cancelJob: (job: JobState) => Promise<boolean>
+  deleteJob: (job: JobState) => Promise<boolean>
+  clearFinished: () => Promise<boolean>
+  isPending: (job: JobState) => boolean
+}
+
+function errorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error ? error.message : fallback
+}
+
+/**
+ * Headless controller for plugin job presentation and actions.
+ *
+ * Every job list is derived directly from the source. The controller never
+ * mirrors source jobs into another ref.
+ */
+export function useJobCenter(
+  options: UseJobCenterOptions = {},
+): UseJobCenterReturn {
+  const isOpen = ref(false)
+  const activeTab = ref<JobsStatusTrayTab>('active')
+  const isLoading = ref(false)
+  const error = shallowRef<string | null>(null)
+  const pendingJobIds = ref(new Set<string>())
+  let requestGeneration = 0
+  let active = true
+  const source = computed(() => toValue(options.source))
+
+  const jobs = computed<JobState[]>(() => {
+    const currentSource = source.value
+    return currentSource ? [...toValue(currentSource.jobs)].map(normalizeJobState) : []
+  })
+  const activeJobs = computed(() => jobs.value.filter(job => isActiveJobStatus(job.status)))
+  const historyJobs = computed(() => jobs.value.filter(job => !isActiveJobStatus(job.status)))
+  const deletableJobs = computed(() => historyJobs.value.filter(job => job.can_delete))
+  const featuredJob = computed(() => activeJobs.value[0] ?? historyJobs.value[0] ?? null)
+  const canRefresh = computed(() => Boolean(source.value?.refresh))
+  const canCancel = computed(() => Boolean(source.value?.cancel))
+  const canDelete = computed(() => Boolean(source.value?.delete))
+  const canClearFinished = computed(() => Boolean(
+    source.value?.clear || source.value?.delete,
+  ))
+
+  function setPending(jobId: string, pending: boolean): void {
+    const next = new Set(pendingJobIds.value)
+    if (pending) next.add(jobId)
+    else next.delete(jobId)
+    pendingJobIds.value = next
+  }
+
+  async function refresh(): Promise<boolean> {
+    const listJobs = source.value?.refresh
+    if (!listJobs) return false
+    const generation = ++requestGeneration
+    isLoading.value = true
+    error.value = null
+    try {
+      await listJobs()
+      return active && generation === requestGeneration
+    } catch (cause) {
+      if (active && generation === requestGeneration) {
+        error.value = errorMessage(cause, 'Failed to load jobs')
+      }
+      return false
+    } finally {
+      if (active && generation === requestGeneration) isLoading.value = false
+    }
+  }
+
+  async function cancelJob(job: JobState): Promise<boolean> {
+    const sourceCancel = source.value?.cancel
+    if (!job.can_cancel || !sourceCancel || pendingJobIds.value.has(job.job_id)) {
+      return false
+    }
+    setPending(job.job_id, true)
+    error.value = null
+    try {
+      await sourceCancel(job.job_id)
+      return active
+    } catch (cause) {
+      if (active) error.value = errorMessage(cause, 'Failed to cancel job')
+      return false
+    } finally {
+      if (active) setPending(job.job_id, false)
+    }
+  }
+
+  async function deleteJob(job: JobState): Promise<boolean> {
+    const sourceDelete = source.value?.delete
+    if (!job.can_delete || !sourceDelete || pendingJobIds.value.has(job.job_id)) {
+      return false
+    }
+    setPending(job.job_id, true)
+    error.value = null
+    try {
+      const deleted = await sourceDelete(job.job_id)
+      return active && deleted !== false
+    } catch (cause) {
+      if (active) error.value = errorMessage(cause, 'Failed to delete job')
+      return false
+    } finally {
+      if (active) setPending(job.job_id, false)
+    }
+  }
+
+  async function clearFinished(): Promise<boolean> {
+    const targets = deletableJobs.value
+    if (targets.length === 0) return false
+    error.value = null
+    try {
+      const currentSource = source.value
+      if (currentSource?.clear) {
+        const deleted = await currentSource.clear()
+        if (!active) return false
+        return typeof deleted !== 'number' || deleted === targets.length
+      }
+      if (!currentSource?.delete) return false
+      const results = await Promise.all(targets.map(job => deleteJob(job)))
+      return results.every(Boolean)
+    } catch (cause) {
+      if (active) error.value = errorMessage(cause, 'Failed to clear jobs')
+      return false
+    }
+  }
+
+  onMounted(() => {
+    if (options.loadOnMount !== false) void refresh()
+  })
+  onUnmounted(() => {
+    active = false
+    requestGeneration += 1
+  })
+
+  return {
+    jobs,
+    activeJobs,
+    historyJobs,
+    deletableJobs,
+    featuredJob,
+    canRefresh,
+    canCancel,
+    canDelete,
+    canClearFinished,
+    isOpen,
+    activeTab,
+    isLoading,
+    error,
+    pendingJobIds,
+    open: () => { isOpen.value = true },
+    close: () => { isOpen.value = false },
+    toggle: () => { isOpen.value = !isOpen.value },
+    refresh,
+    cancelJob,
+    deleteJob,
+    clearFinished,
+    isPending: job => pendingJobIds.value.has(job.job_id),
+  }
+}