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

package/src/components/ArtifactSaveDialog.vue

@@ -0,0 +1,434 @@
+<script setup lang="ts">
+/** Save/update dialog for analysis artifacts; delegates the write to a plugin-supplied handler. */
+import { computed, ref, shallowRef, watch } from 'vue'
+import BaseModal from './BaseModal.vue'
+import BaseInput from './BaseInput.vue'
+import BaseTextarea from './BaseTextarea.vue'
+import BaseButton from './BaseButton.vue'
+import AlertBox from './AlertBox.vue'
+import FormField from './FormField.vue'
+import FileUploader from './FileUploader.vue'
+import SegmentedControl from './SegmentedControl.vue'
+import { useRequestSyncState } from '../composables/useRequestSyncState'
+import {
+  getInjectedPlatformContext,
+  resolveCurrentExperimentId,
+} from '../composables/platformContextHelpers'
+import {
+  ANALYSIS_FILE_ARTIFACT_SCHEMA,
+  type AnalysisArtifactDetail,
+  type ArtifactFileSource,
+  type ArtifactSaveDialogHandler,
+  type ArtifactSaveDialogPayload,
+  type ArtifactSaveHandler,
+  type ArtifactSaveResult,
+  type HandlerArtifactSaveHandler,
+} from '../types/analysisArtifactTypes'
+import type { ModalSize } from '../types'
+
+interface Props {
+  modelValue: boolean
+  /** Performs the backend write; the dialog never calls the platform itself. */
+  saveHandler: ArtifactSaveDialogHandler
+  /** Which artifact kinds the form offers. */
+  mode?: 'json' | 'file' | 'both'
+  /** Use `handler` when the plugin backend serializes the file content itself. */
+  fileSource?: ArtifactFileSource
+  /** JSON result payload supplied programmatically by the host. */
+  result?: Record<string, unknown>
+  /** Experiment id override; defaults to platform injection or URL. */
+  experimentId?: number | null
+  /** Existing artifact detail; when set the dialog updates instead of creating. */
+  existingArtifact?: AnalysisArtifactDetail | null
+  /** Known artifact keys, used to warn (json) or block (file) on collisions. */
+  existingArtifactKeys?: string[]
+  title?: string
+  size?: ModalSize
+  defaultArtifactKey?: string
+  defaultDisplayName?: string
+  /** Maps to the Python `kind=` argument for new file artifacts. */
+  defaultFileKind?: string
+  /** Forwarded to the file uploader. */
+  accept?: string
+  /** Forwarded to the file uploader (bytes). */
+  maxFileSize?: number
+  /**
+   * Result metadata for file artifacts. Backend-side this REPLACES the previous
+   * metadata; on replacement the existing artifact's metadata is carried through
+   * unless this prop supplies a new map.
+   */
+  metadata?: Record<string, unknown>
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  mode: 'file',
+  fileSource: 'upload',
+  experimentId: null,
+  existingArtifact: null,
+  size: 'md',
+  defaultArtifactKey: 'default',
+  defaultFileKind: 'file',
+})
+
+const emit = defineEmits<{
+  'update:modelValue': [value: boolean]
+  saved: [result: ArtifactSaveResult & { payload: ArtifactSaveDialogPayload }]
+  error: [message: string]
+  cancel: []
+}>()
+
+const ARTIFACT_KEY_PATTERN = /^[a-z0-9][a-z0-9._-]*$/
+
+const injectedContext = getInjectedPlatformContext()
+const request = useRequestSyncState('Failed to save analysis artifact.')
+
+const isUpdate = computed(() => props.existingArtifact !== null)
+const existingResult = computed(
+  () => (props.existingArtifact?.result ?? {}) as Record<string, unknown>,
+)
+const existingIsFile = computed(
+  () => existingResult.value.schema_version === ANALYSIS_FILE_ARTIFACT_SCHEMA,
+)
+const existingFileKind = computed(() =>
+  typeof existingResult.value.kind === 'string' ? existingResult.value.kind : undefined)
+const existingFilename = computed(() =>
+  typeof existingResult.value.filename === 'string' ? existingResult.value.filename : undefined)
+const existingMetadata = computed(() => {
+  const value = existingResult.value.metadata
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined
+})
+
+const activeKind = ref<'json' | 'file'>('file')
+const keyInput = ref('')
+const displayNameInput = ref('')
+const noteInput = ref('')
+const selectedFile = shallowRef<File | null>(null)
+let initialNote = ''
+
+function resetForm(): void {
+  const existing = props.existingArtifact
+  activeKind.value = existing
+    ? (existingIsFile.value ? 'file' : 'json')
+    : (props.mode === 'json' ? 'json' : 'file')
+  keyInput.value = existing?.artifact_key ?? props.defaultArtifactKey
+  displayNameInput.value = existing?.display_name ?? props.defaultDisplayName ?? ''
+  initialNote = existing?.note ?? ''
+  noteInput.value = initialNote
+  selectedFile.value = null
+  request.clearError()
+}
+
+resetForm()
+watch(() => props.modelValue, (open) => {
+  if (open) resetForm()
+})
+// Key off identity, not object reference: re-fetching the same artifact must not
+// wipe in-progress edits.
+watch(
+  () => (props.existingArtifact ? `${props.existingArtifact.id}:${props.existingArtifact.artifact_key}` : null),
+  resetForm,
+)
+
+const resolvedTitle = computed(() =>
+  props.title ?? (isUpdate.value ? 'Update Analysis Artifact' : 'Save Analysis Artifact'))
+const showKindToggle = computed(() => !isUpdate.value && props.mode === 'both')
+const showFileUploader = computed(
+  () => activeKind.value === 'file' && props.fileSource === 'upload',
+)
+// save_analysis_artifact ignores note=None (it preserves), so a JSON artifact's
+// note cannot be cleared through the save path — that belongs to updateMetadata.
+// update_analysis_file_artifact does honour the not-provided/null/value sentinel.
+const showNoteField = computed(() => !isUpdate.value || existingIsFile.value)
+
+const effectiveKey = computed(() => {
+  if (isUpdate.value) return props.existingArtifact?.artifact_key ?? ''
+  return keyInput.value.trim() || props.defaultArtifactKey
+})
+const keyValid = computed(() => ARTIFACT_KEY_PATTERN.test(effectiveKey.value))
+const keyExists = computed(
+  () => !isUpdate.value && (props.existingArtifactKeys ?? []).includes(effectiveKey.value),
+)
+// A file artifact is create-only: reusing a key always fails backend-side, and the
+// dialog has no detail to replace it safely. JSON keys upsert natively, so warn only.
+const keyBlocked = computed(() => keyExists.value && activeKind.value === 'file')
+const keyError = computed(() => {
+  if (!keyValid.value) return 'Use lowercase letters, digits, dots, dashes, or underscores.'
+  if (keyBlocked.value) return 'This key is already used. Choose another, or replace the existing artifact.'
+  return undefined
+})
+
+const canSubmit = computed(() => {
+  if (request.loading.value || !keyValid.value || keyBlocked.value) return false
+  if (activeKind.value === 'file') {
+    return props.fileSource === 'handler' || selectedFile.value !== null
+  }
+  return props.result !== undefined
+})
+
+function resolveExperimentId(): number | undefined {
+  return props.experimentId ?? resolveCurrentExperimentId(injectedContext)
+}
+
+/** Set-only note for creates and JSON upserts: an empty field just sends nothing. */
+function createNotePayload(): { note?: string } {
+  const value = noteInput.value.trim()
+  return showNoteField.value && value ? { note: value } : {}
+}
+
+/**
+ * Three-state note, honoured only by update_analysis_file_artifact:
+ * omitted = preserve, null = clear, string = set.
+ */
+function updateNotePayload(): { note?: string | null } {
+  if (noteInput.value === initialNote) return {}
+  const value = noteInput.value.trim()
+  return value ? { note: value } : { note: null }
+}
+
+function buildPayload(experimentId: number): ArtifactSaveDialogPayload | null {
+  const base = {
+    experimentId,
+    artifactKey: effectiveKey.value,
+  }
+  if (activeKind.value === 'json') {
+    if (props.result === undefined) return null
+    // Upsert only sets display_name when provided; pass the existing one through
+    // on update so a re-save never blanks it.
+    const displayName = isUpdate.value
+      ? props.existingArtifact?.display_name
+      : displayNameInput.value.trim() || undefined
+    return {
+      kind: 'json',
+      mode: isUpdate.value || keyExists.value ? 'upsert' : 'create',
+      ...base,
+      ...createNotePayload(),
+      ...(displayName ? { displayName } : {}),
+      result: props.result,
+    }
+  }
+  if (isUpdate.value) {
+    // Metadata replaces rather than merges backend-side, so send the full intended
+    // map: the caller's override, else whatever the artifact already carries.
+    const metadata = props.metadata ?? existingMetadata.value
+    if (props.fileSource === 'handler') {
+      return {
+        kind: 'file',
+        source: 'handler',
+        mode: 'update',
+        ...base,
+        ...updateNotePayload(),
+        fileKind: existingFileKind.value ?? props.defaultFileKind,
+        ...(metadata ? { metadata } : {}),
+      }
+    }
+    const file = selectedFile.value
+    if (!file) return null
+    return {
+      kind: 'file',
+      mode: 'update',
+      ...base,
+      ...updateNotePayload(),
+      file,
+      // kind is immutable backend-side; always echo the artifact's own kind.
+      fileKind: existingFileKind.value ?? props.defaultFileKind,
+      ...(metadata ? { metadata } : {}),
+      ...(file.type ? { contentType: file.type } : {}),
+    }
+  }
+  const displayName = displayNameInput.value.trim()
+  if (props.fileSource === 'handler') {
+    return {
+      kind: 'file',
+      source: 'handler',
+      mode: 'create',
+      ...base,
+      ...createNotePayload(),
+      fileKind: props.defaultFileKind,
+      ...(displayName ? { displayName } : {}),
+      ...(props.metadata ? { metadata: props.metadata } : {}),
+    }
+  }
+  const file = selectedFile.value
+  if (!file) return null
+  return {
+    kind: 'file',
+    mode: 'create',
+    ...base,
+    ...createNotePayload(),
+    file,
+    fileKind: props.defaultFileKind,
+    filename: file.name,
+    ...(displayName ? { displayName } : {}),
+    ...(props.metadata ? { metadata: props.metadata } : {}),
+    ...(file.type ? { contentType: file.type } : {}),
+  }
+}
+
+function runSaveHandler(
+  payload: ArtifactSaveDialogPayload,
+): Promise<ArtifactSaveResult | void> {
+  if (props.fileSource === 'handler') {
+    if (payload.kind === 'file' && !('source' in payload)) {
+      throw new Error('ArtifactSaveDialog built an upload payload for a handler-owned file.')
+    }
+    return (props.saveHandler as HandlerArtifactSaveHandler)(payload)
+  }
+  if (payload.kind === 'file' && 'source' in payload) {
+    throw new Error('ArtifactSaveDialog built a handler-owned payload for an uploaded file.')
+  }
+  return (props.saveHandler as ArtifactSaveHandler)(payload)
+}
+
+function handleFileUpload(files: File[]): void {
+  selectedFile.value = files[0] ?? null
+}
+
+function handleFileError(message: string): void {
+  request.setError(message)
+}
+
+async function handleSubmit(): Promise<void> {
+  if (!canSubmit.value) return
+  const experimentId = resolveExperimentId()
+  if (experimentId === undefined) {
+    const message = request.setError('No experiment is available for saving an artifact.')
+    emit('error', message)
+    return
+  }
+  const payload = buildPayload(experimentId)
+  if (!payload) return
+  try {
+    const result = await request.run(
+      () => runSaveHandler(payload),
+      { success: 'save', errorMessage: 'Failed to save analysis artifact.' },
+    )
+    emit('saved', { ...(result ?? {}), payload })
+    emit('update:modelValue', false)
+    resetForm()
+  } catch {
+    emit('error', request.error.value ?? 'Failed to save analysis artifact.')
+  }
+}
+
+function handleCancel(): void {
+  emit('cancel')
+  emit('update:modelValue', false)
+}
+</script>
+
+<template>
+  <BaseModal
+    :model-value="modelValue"
+    :title="resolvedTitle"
+    :size="size"
+    :closable="!request.loading.value"
+    @update:model-value="emit('update:modelValue', $event)"
+    @close="emit('cancel')"
+  >
+    <div class="mint-artifact-save-dialog">
+      <SegmentedControl
+        v-if="showKindToggle"
+        v-model="activeKind"
+        class="mint-artifact-save-dialog__kind-toggle"
+        :options="[
+          { value: 'file', label: 'File' },
+          { value: 'json', label: 'JSON' },
+        ]"
+        full-width
+      />
+
+      <AlertBox
+        v-if="keyExists && !keyBlocked"
+        type="warning"
+        class="mint-artifact-save-dialog__warning"
+      >
+        An artifact with key "{{ effectiveKey }}" already exists. Its results will be
+        replaced; its name and note are kept unless you set new ones.
+      </AlertBox>
+
+      <FormField
+        label="Artifact key"
+        class="mint-artifact-save-dialog__key"
+        :error="keyError"
+        :hint="isUpdate ? 'Keys are fixed once an artifact exists.' : undefined"
+      >
+        <BaseInput
+          v-model="keyInput"
+          :readonly="isUpdate"
+          :error="Boolean(keyError)"
+          :placeholder="defaultArtifactKey"
+        />
+      </FormField>
+
+      <FormField
+        v-if="!isUpdate"
+        label="Display name"
+        class="mint-artifact-save-dialog__name"
+      >
+        <BaseInput
+          v-model="displayNameInput"
+          placeholder="Shown in artifact lists"
+        />
+      </FormField>
+
+      <FormField
+        v-if="showNoteField"
+        label="Note"
+        class="mint-artifact-save-dialog__note"
+      >
+        <BaseTextarea
+          v-model="noteInput"
+          placeholder="Optional context for this artifact"
+        />
+      </FormField>
+
+      <template v-if="activeKind === 'file'">
+        <FileUploader
+          v-if="showFileUploader"
+          class="mint-artifact-save-dialog__file"
+          :accept="accept"
+          :max-size="maxFileSize"
+          :multiple="false"
+          @upload="handleFileUpload"
+          @error="handleFileError"
+        />
+        <p
+          v-if="isUpdate && existingFilename"
+          class="mint-artifact-save-dialog__immutable"
+        >
+          Replaces the content of <code>{{ existingFilename }}</code> (kind
+          <code>{{ existingFileKind ?? defaultFileKind }}</code>); filename and kind stay unchanged.
+        </p>
+      </template>
+
+      <AlertBox
+        v-if="request.error.value"
+        type="error"
+        class="mint-artifact-save-dialog__error"
+        role="alert"
+      >
+        {{ request.error.value }}
+      </AlertBox>
+    </div>
+
+    <template #footer>
+      <BaseButton variant="secondary" :disabled="request.loading.value" @click="handleCancel">
+        Cancel
+      </BaseButton>
+      <BaseButton
+        class="mint-artifact-save-dialog__submit"
+        :loading="request.loading.value"
+        :disabled="!canSubmit"
+        @click="handleSubmit"
+      >
+        {{ isUpdate ? 'Update Artifact' : 'Save Artifact' }}
+      </BaseButton>
+    </template>
+  </BaseModal>
+</template>
+
+<style>
+@import '../styles/components/artifact-save-dialog.css';
+</style>