@morscherlab/mint-sdk 1.2.0-beta.8 → 1.2.0

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

@@ -89,4 +89,144 @@ describe('useRequestSyncState', () => {
     expect(state.lastSavedAt.value).toBeNull()
     expect(state.lastRunAt.value).toBeNull()
   })
+
+  describe('stale-response guard', () => {
+    function deferred<T>() {
+      let resolve!: (value: T) => void
+      let reject!: (reason: unknown) => void
+      const promise = new Promise<T>((res, rej) => {
+        resolve = res
+        reject = rej
+      })
+      return { promise, resolve, reject }
+    }
+
+    it('lets only the newest run own loading', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+
+      const firstRun = state.run(() => first.promise, { success: 'load' })
+      const secondRun = state.run(() => second.promise, { success: 'load' })
+
+      first.resolve('stale')
+      await expect(firstRun).resolves.toBe('stale')
+      expect(state.loading.value).toBe(true)
+
+      second.resolve('fresh')
+      await expect(secondRun).resolves.toBe('fresh')
+      expect(state.loading.value).toBe(false)
+    })
+
+    it('does not let a stale success move the sync timestamps', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+
+      const firstRun = state.run(() => first.promise, { success: 'save' })
+      const secondRun = state.run(() => second.promise, { success: 'load' })
+
+      first.resolve('stale')
+      await firstRun
+      expect(state.lastSavedAt.value).toBeNull()
+
+      second.resolve('fresh')
+      await secondRun
+      expect(state.lastLoadedAt.value).toBeInstanceOf(Date)
+      expect(state.lastSavedAt.value).toBeNull()
+    })
+
+    it('does not let a stale failure write the error, but still rejects its caller', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+
+      const firstRun = state.run(() => first.promise, { errorMessage: 'first failed' })
+      const secondRun = state.run(() => second.promise, { success: 'load' })
+
+      first.reject(new Error('stale failure'))
+      await expect(firstRun).rejects.toThrow('stale failure')
+      expect(state.error.value).toBeNull()
+
+      second.resolve('fresh')
+      await secondRun
+      expect(state.error.value).toBeNull()
+      expect(state.loading.value).toBe(false)
+    })
+
+    it('aborts the superseded run signal by default', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+      let firstSignal: AbortSignal | undefined
+
+      const firstRun = state.run((signal) => {
+        firstSignal = signal
+        return first.promise
+      })
+      expect(firstSignal?.aborted).toBe(false)
+
+      const secondRun = state.run(() => second.promise)
+      expect(firstSignal?.aborted).toBe(true)
+
+      first.resolve('stale')
+      second.resolve('fresh')
+      await Promise.all([firstRun, secondRun])
+    })
+
+    it('leaves the previous signal alone when abortPrevious is false', async () => {
+      const state = useRequestSyncState()
+      const first = deferred<string>()
+      const second = deferred<string>()
+      let firstSignal: AbortSignal | undefined
+
+      const firstRun = state.run((signal) => {
+        firstSignal = signal
+        return first.promise
+      })
+      const secondRun = state.run(() => second.promise, { abortPrevious: false })
+
+      expect(firstSignal?.aborted).toBe(false)
+      first.resolve('stale')
+      second.resolve('fresh')
+      await Promise.all([firstRun, secondRun])
+    })
+
+    it('forwards a caller signal onto the operation signal', async () => {
+      const state = useRequestSyncState()
+      const caller = new AbortController()
+      const pending = deferred<string>()
+      let operationSignal: AbortSignal | undefined
+
+      const run = state.run((signal) => {
+        operationSignal = signal
+        return pending.promise
+      }, { signal: caller.signal })
+
+      caller.abort()
+      expect(operationSignal?.aborted).toBe(true)
+
+      pending.resolve('done')
+      await run
+    })
+
+    it('cancel() aborts the in-flight run and drops loading', async () => {
+      const state = useRequestSyncState()
+      const pending = deferred<string>()
+      let operationSignal: AbortSignal | undefined
+
+      const run = state.run((signal) => {
+        operationSignal = signal
+        return pending.promise
+      }, { success: 'load' })
+
+      state.cancel()
+      expect(operationSignal?.aborted).toBe(true)
+      expect(state.loading.value).toBe(false)
+
+      pending.resolve('too late')
+      await expect(run).resolves.toBe('too late')
+      expect(state.lastLoadedAt.value).toBeNull()
+    })
+  })
 })

package/src/__tests__/stores/settings.test.ts

@@ -1,6 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createPinia, setActivePinia } from 'pinia'
-import { useSettingsStore } from '../../stores/settings'
+import { nextTick } from 'vue'
+import {
+  paletteCssVariables,
+  tableDensityToSize,
+  tryUseSettingsStore,
+  useSettingsStore,
+} from '../../stores/settings'
 
 function mockMatchMedia(matches = false) {
   Object.defineProperty(window, 'matchMedia', {
@@ -46,6 +52,8 @@ describe('useSettingsStore', () => {
     setActivePinia(createPinia())
     installLocalStorage()
     document.documentElement.classList.remove('dark')
+    document.documentElement.removeAttribute('style')
+    delete document.documentElement.dataset.density
     mockMatchMedia(false)
   })
 
@@ -75,4 +83,66 @@ describe('useSettingsStore', () => {
       tableDensity: 'compact',
     }))
   })
+
+  describe('palette and density DOM sync', () => {
+    it('writes no palette overrides for the default palette', () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      expect(paletteCssVariables('default')).toEqual({})
+      expect(document.documentElement.style.getPropertyValue('--color-primary')).toBe('')
+    })
+
+    it('applies the stored palette hues to html on initialize', () => {
+      localStorage.setItem('mint-settings', JSON.stringify({ colorPalette: 'viridis' }))
+
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      const style = document.documentElement.style
+      expect(style.getPropertyValue('--color-primary')).toBe('hsl(280 84% 67%)')
+      expect(style.getPropertyValue('--color-primary-hover')).toBe('hsl(280 75% 59%)')
+      expect(style.getPropertyValue('--color-cta')).toBe('hsl(80 95% 53%)')
+    })
+
+    it('re-applies the overrides when the palette changes and clears them on default', async () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      settings.colorPalette = 'pastel'
+      await nextTick()
+      expect(document.documentElement.style.getPropertyValue('--color-primary')).toBe('hsl(200 84% 67%)')
+
+      settings.colorPalette = 'default'
+      await nextTick()
+      expect(document.documentElement.style.getPropertyValue('--color-primary')).toBe('')
+      expect(document.documentElement.style.getPropertyValue('--color-primary-soft')).toBe('')
+    })
+
+    it('mirrors the table density onto html[data-density]', async () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+      expect(document.documentElement.dataset.density).toBe('normal')
+
+      settings.tableDensity = 'compact'
+      await nextTick()
+      expect(document.documentElement.dataset.density).toBe('compact')
+    })
+
+    it('maps each density onto a table size', () => {
+      const settings = useSettingsStore()
+      settings.initialize()
+
+      expect(tableDensityToSize('compact')).toBe('sm')
+      expect(tableDensityToSize('normal')).toBe('md')
+      expect(tableDensityToSize('comfortable')).toBe('lg')
+
+      settings.tableDensity = 'comfortable'
+      expect(settings.getTableSize()).toBe('lg')
+    })
+  })
+
+  it('exposes the store through tryUseSettingsStore when Pinia is active', () => {
+    expect(tryUseSettingsStore()).not.toBeNull()
+  })
 })

package/src/__tests__/styles/cssTokens.test.ts

@@ -0,0 +1,131 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const srcRoot = resolve(here, '../..')
+const stylesDir = join(srcRoot, 'styles')
+const variablesCss = readFileSync(join(stylesDir, 'variables.css'), 'utf-8')
+
+/**
+ * Custom properties that are legitimately *not* declared in variables.css:
+ * they are set at runtime (inline `:style` bindings, JS-built names) or are
+ * component-local knobs declared in the same stylesheet that consumes them.
+ * Anything else must be a canonical token from variables.css.
+ */
+const RUNTIME_PROPERTY_ALLOWLIST = new Set<string>([
+  // Names assembled in JS (`--grp-${i}`) — the literal prefix is what the
+  // scanner sees in a template string.
+  '--grp-',
+])
+
+const SOURCE_EXTENSIONS = ['.vue', '.css', '.ts']
+const IGNORED_DIRS = new Set(['__tests__', 'generated-ui', 'node_modules'])
+
+function walk(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry)
+    if (statSync(full).isDirectory()) {
+      if (!IGNORED_DIRS.has(entry)) walk(full, out)
+    } else if (SOURCE_EXTENSIONS.some((ext) => entry.endsWith(ext))) {
+      out.push(full)
+    }
+  }
+  return out
+}
+
+const sourceFiles = walk(srcRoot)
+
+function declaredIn(text: string): Set<string> {
+  const names = new Set<string>()
+  // `--foo: value` declarations, in CSS blocks and in JS style objects.
+  for (const m of text.matchAll(/(--[A-Za-z0-9_-]+)\s*:/g)) names.add(m[1])
+  // setProperty('--foo', …) / `'--foo'` keys in style bindings.
+  for (const m of text.matchAll(/['"`](--[A-Za-z0-9_-]+)['"`]/g)) names.add(m[1])
+  return names
+}
+
+const canonicalTokens = declaredIn(variablesCss)
+
+// Component-local custom properties: declared in a stylesheet or set from an
+// inline `:style` binding in the SFC that owns it. They are legitimate, they
+// just are not part of the global token set.
+const componentLocalProperties = new Set<string>()
+for (const file of sourceFiles) {
+  for (const name of declaredIn(readFileSync(file, 'utf-8'))) {
+    componentLocalProperties.add(name)
+  }
+}
+
+interface Usage {
+  file: string
+  token: string
+}
+
+const usages: Usage[] = []
+for (const file of sourceFiles) {
+  const text = readFileSync(file, 'utf-8')
+  for (const m of text.matchAll(/var\(\s*(--[A-Za-z0-9_-]+)/g)) {
+    usages.push({ file, token: m[1] })
+  }
+}
+
+describe('CSS custom properties', () => {
+  it('scans a meaningful number of var() references', () => {
+    expect(usages.length).toBeGreaterThan(500)
+    expect(canonicalTokens.size).toBeGreaterThan(70)
+  })
+
+  it('only references custom properties that are actually defined', () => {
+    const undefinedUsages = usages.filter(({ token }) => {
+      if (canonicalTokens.has(token)) return false
+      if (RUNTIME_PROPERTY_ALLOWLIST.has(token)) return false
+      return !componentLocalProperties.has(token)
+    })
+
+    const report = [
+      ...new Set(
+        undefinedUsages.map(
+          ({ file, token }) => `${token} (${relative(srcRoot, file)})`,
+        ),
+      ),
+    ].sort()
+
+    expect(report).toEqual([])
+  })
+
+  it('does not use the platform-only --color-bg-*/--color-text-*/--color-border aliases', () => {
+    const platformOnly = /^--color-(bg|text)-|^--color-border$/
+    const offenders = [
+      ...new Set(
+        usages
+          .filter(({ token }) => platformOnly.test(token))
+          .map(({ file, token }) => `${token} (${relative(srcRoot, file)})`),
+      ),
+    ].sort()
+
+    expect(offenders).toEqual([])
+  })
+
+  it('aggregates every component stylesheet in styles/index.css', () => {
+    const index = readFileSync(join(stylesDir, 'index.css'), 'utf-8')
+    const imported = new Set(
+      [...index.matchAll(/@import\s+'\.\/components\/([^']+)'/g)].map((m) => m[1]),
+    )
+    const onDisk = readdirSync(join(stylesDir, 'components')).filter((f) =>
+      f.endsWith('.css'),
+    )
+    expect([...onDisk].filter((f) => !imported.has(f)).sort()).toEqual([])
+  })
+
+  it('does not re-import aggregated stylesheets from SFC <style> blocks', () => {
+    const offenders = sourceFiles
+      .filter((f) => f.endsWith('.vue'))
+      .filter((f) => /@import\s+['"][^'"]*styles\/components\//.test(readFileSync(f, 'utf-8')))
+      .map((f) => relative(srcRoot, f))
+      .sort()
+
+    expect(offenders).toEqual([])
+  })
+})

package/src/__tests__/utils/permissions.test.ts

@@ -7,6 +7,7 @@ import {
   hasAllPermissions,
   hasAnyPermission,
   isAdminUser,
+  normalizeAccessPolicy,
 } from '../../permissions'
 
 describe('permission helpers', () => {
@@ -60,3 +61,70 @@ describe('permission helpers', () => {
     expect(canAccessByPolicy(member, { plugin: 'reports' })).toBe(false)
   })
 })
+
+describe('normalizeAccessPolicy precedence', () => {
+  it('returns an empty policy for an absent rule', () => {
+    expect(normalizeAccessPolicy(undefined)).toEqual({})
+  })
+
+  it('reads a flat-only rule as-is', () => {
+    expect(normalizeAccessPolicy({
+      visibleFor: 'admin',
+      requiresAdmin: true,
+      permissions: ['users.manage'],
+      anyPermissions: ['plugins.install'],
+    })).toEqual({
+      visibleFor: 'admin',
+      requiresAdmin: true,
+      permissions: ['users.manage'],
+      anyPermissions: ['plugins.install'],
+    })
+  })
+
+  it('lifts a nested-only policy to the top level', () => {
+    expect(normalizeAccessPolicy({
+      access: { requiresAuth: true, plugin: 'reports', visibleFor: 'admin' },
+    })).toEqual({
+      requiresAuth: true,
+      plugin: 'reports',
+      visibleFor: 'admin',
+    })
+  })
+
+  it('lets the nested policy win over the deprecated flat duplicates', () => {
+    expect(normalizeAccessPolicy({
+      access: {
+        visibleFor: 'admin',
+        requiresAdmin: true,
+        permissions: ['users.manage'],
+        anyPermissions: ['plugins.install'],
+      },
+      visibleFor: 'user',
+      requiresAdmin: false,
+      permissions: ['experiments.view'],
+      anyPermissions: ['experiments.edit'],
+    })).toEqual({
+      visibleFor: 'admin',
+      requiresAdmin: true,
+      permissions: ['users.manage'],
+      anyPermissions: ['plugins.install'],
+    })
+  })
+
+  it('treats an undefined nested field as unset instead of masking the flat one', () => {
+    expect(normalizeAccessPolicy({
+      access: { visibleFor: undefined, requiresAdmin: true },
+      visibleFor: 'user',
+    })).toEqual({
+      visibleFor: 'user',
+      requiresAdmin: true,
+    })
+  })
+
+  it('feeds canAccessByPolicy from the nested policy', () => {
+    const member = { role: 'member', permissions: ['experiments.view'] }
+
+    expect(canAccessByPolicy(member, { access: { requiresAdmin: true }, requiresAdmin: false })).toBe(false)
+    expect(canAccessByPolicy(member, { access: { visibleFor: 'user' }, visibleFor: 'admin' })).toBe(true)
+  })
+})

package/src/apiErrors.ts

@@ -0,0 +1,85 @@
+export interface MintApiErrorEnvelope {
+  code: string
+  message: string
+  status: number
+  request_id: string | null
+  details: unknown
+  detail?: unknown
+}
+
+const STATUS_MESSAGES: Readonly<Record<number, string>> = {
+  400: 'Bad request',
+  401: 'Authentication required',
+  403: 'Permission denied',
+  404: 'Resource not found',
+  405: 'Method not allowed',
+  409: 'Conflict',
+  413: 'Payload too large',
+  415: 'Unsupported media type',
+  422: 'Validation error',
+  429: 'Rate limit exceeded',
+  500: 'Internal server error',
+  502: 'Bad gateway',
+  503: 'Service unavailable',
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
+
+/** Public error thrown by typed MINT SDK requests. */
+export class MintApiError extends Error {
+  override readonly name: string = 'MintApiError'
+
+  constructor(
+    message: string,
+    readonly code: string,
+    readonly status: number,
+    readonly requestId: string | null,
+    readonly details: unknown,
+    readonly detail: unknown,
+    readonly body: unknown,
+    readonly cause?: unknown,
+  ) {
+    super(message)
+  }
+}
+
+export interface MintApiErrorOptions {
+  requestId?: string | null
+  cause?: unknown
+}
+
+/** Normalize current typed envelopes and the previous FastAPI detail shape. */
+export function mintApiErrorFromResponse(
+  status: number,
+  payload: unknown,
+  options: MintApiErrorOptions = {},
+): MintApiError {
+  const body = asRecord(payload)
+  const legacyDetail = body?.detail
+  const inner = asRecord(legacyDetail) ?? body
+  const text = (value: unknown): string | undefined =>
+    typeof value === 'string' && value ? value : undefined
+  // Complete envelopes own the public code; older wrappers defer to the plugin payload.
+  const canonical = typeof body?.status === 'number' && text(body.code) && text(body.message)
+  const code = (canonical ? text(body.code) : text(inner?.error) ?? text(inner?.code))
+    ?? text(body?.code) ?? 'unknown'
+  const message = (canonical ? text(body.message) : text(inner?.message))
+    ?? text(body?.message) ?? text(legacyDetail)
+    ?? STATUS_MESSAGES[status] ?? `HTTP ${status}`
+  const details = body?.details ?? inner?.details ?? null
+  const requestId = text(body?.request_id) ?? text(inner?.request_id) ?? options.requestId ?? null
+
+  return new MintApiError(
+    message,
+    code,
+    status,
+    requestId,
+    details,
+    legacyDetail,
+    payload,
+    options.cause,
+  )
+}