@morscherlab/mint-sdk 1.0.0-rc.1 → 1.0.0-rc.4

package/src/lcms.ts

@@ -0,0 +1,108 @@
+import type { LcmsPlateCell, LcmsPlateType } from './utils/rack'
+
+export type LcmsPolarity = 'POS' | 'NEG' | 'BOTH'
+export type LcmsContainerType = 'VIAL' | 'PLATE'
+
+export interface LcmsSequenceItem {
+  sample_type: string
+  file_name: string
+  sample_id: string
+  path: string
+  instrument_method: string
+  position: string
+  injection_volume: number
+}
+
+export interface LcmsSequenceTableColumn {
+  key: keyof LcmsSequenceItem | 'index' | 'actions'
+  label: string
+  align?: 'left' | 'right'
+}
+
+export const DEFAULT_LCMS_SEQUENCE_COLUMNS: LcmsSequenceTableColumn[] = [
+  { key: 'index', label: '#' },
+  { key: 'sample_type', label: 'Type' },
+  { key: 'file_name', label: 'File Name' },
+  { key: 'position', label: 'Position' },
+  { key: 'instrument_method', label: 'Method' },
+  { key: 'injection_volume', label: 'Inj Vol', align: 'right' },
+]
+
+export function extractLcmsCommonPrefix(fileNames: readonly string[]): string {
+  if (fileNames.length === 0) return ''
+  const stripped = fileNames.map(fileName => fileName.replace(/_\d{3}$/, ''))
+  const prefixes = stripped.map((fileName) => {
+    const match = fileName.match(/^(.+?)_(POS|NEG)_/i)
+    return match ? match[1] : fileName.replace(/_[^_]+$/, '')
+  })
+
+  let common = prefixes[0] ?? ''
+  for (const prefix of prefixes.slice(1)) {
+    while (common && !prefix.startsWith(common)) {
+      const index = common.lastIndexOf('_')
+      common = index > 0 ? common.substring(0, index) : common.substring(0, common.length - 1)
+    }
+  }
+  return common
+}
+
+export function extractLcmsSampleName(fileName: string, prefix = ''): string {
+  let name = fileName.replace(/_\d{3}$/, '')
+  if (prefix && name.startsWith(prefix)) {
+    name = name.substring(prefix.length).replace(/^_+/, '')
+  }
+  name = name.replace(/^(POS|NEG)_/i, '')
+  return name || fileName
+}
+
+export function lcmsWellIdFromPosition(position: string): string {
+  return position.includes(':') ? position.split(':').pop() ?? position : position
+}
+
+export function inferLcmsPlateTypeFromWellIds(wellIds: readonly string[]): LcmsPlateType | null {
+  let maxCol = 0
+  let maxRow = 0
+  for (const wellId of wellIds) {
+    const match = wellId.match(/^([A-Z])(\d+)$/i)
+    if (!match) continue
+    maxRow = Math.max(maxRow, match[1].toUpperCase().charCodeAt(0) - 64)
+    maxCol = Math.max(maxCol, Number(match[2]))
+  }
+  if (maxCol === 0 && maxRow === 0) return null
+  return maxCol <= 9 && maxRow <= 6 ? '54vial' : '96well'
+}
+
+export function reconstructLcmsPlateCellsFromSequenceItems(
+  items: readonly LcmsSequenceItem[],
+): { cells: LcmsPlateCell[]; plateType: LcmsPlateType } | null {
+  const unknownItems = items.filter(item => item.sample_type === 'Unknown')
+  if (unknownItems.length === 0) return null
+
+  const prefix = extractLcmsCommonPrefix(unknownItems.map(item => item.file_name))
+  const seen = new Set<string>()
+  const cells: LcmsPlateCell[] = []
+
+  for (const item of unknownItems) {
+    const wellId = lcmsWellIdFromPosition(item.position)
+    if (seen.has(wellId)) continue
+    seen.add(wellId)
+
+    const match = wellId.match(/^([A-Z])(\d+)$/i)
+    if (!match) continue
+    cells.push({
+      row: match[1].toUpperCase(),
+      column: Number(match[2]),
+      sample_name: extractLcmsSampleName(item.file_name, prefix),
+    })
+  }
+
+  if (cells.length === 0) return null
+  const plateType = inferLcmsPlateTypeFromWellIds(cells.map(cell => `${cell.row}${cell.column}`))
+  if (!plateType) return null
+  return { cells, plateType }
+}
+
+export function basenameFromWindowsPath(path: string | null | undefined): string {
+  if (!path) return ''
+  return path.split(/[\\/]/).pop() ?? path
+}

package/src/permissions.ts

@@ -0,0 +1,143 @@
+export const ADMIN_ROLE = 'admin'
+
+export const ADMIN_PANEL_PERMISSIONS = [
+  'users.view',
+  'users.invite',
+  'users.manage',
+  'platform.configure',
+  'platform.view_logs',
+  'plugins.configure',
+  'plugins.install',
+] as const
+
+export type AccessAudience = 'all' | 'admin' | 'user'
+export type AccessAudienceInput = AccessAudience | readonly AccessAudience[]
+
+export interface RoleInfo {
+  id?: number
+  slug: string
+  name?: string
+  color?: string
+  permissions?: readonly string[] | null
+  project_scope?: 'all' | 'assigned' | string
+  plugin_access?: readonly string[] | 'all' | null
+}
+
+export interface PermissionUser {
+  role?: string | null
+  role_obj?: RoleInfo | null
+  roleObj?: RoleInfo | null
+  permissions?: readonly string[] | null
+}
+
+export interface AccessPolicy {
+  audience?: AccessAudienceInput
+  visibleFor?: AccessAudienceInput
+  requiresAuth?: boolean
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
+  plugin?: string
+}
+
+export interface AccessControlled {
+  access?: AccessPolicy
+  visibleFor?: AccessAudienceInput
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
+}
+
+export function getRoleInfo(user: PermissionUser | null | undefined): RoleInfo | null {
+  return user?.roleObj ?? user?.role_obj ?? null
+}
+
+export function isAdminRole(role: string | null | undefined): boolean {
+  return role === ADMIN_ROLE
+}
+
+export function isAdminUser(user: PermissionUser | null | undefined): boolean {
+  return isAdminRole(user?.role) || getRoleInfo(user)?.slug === ADMIN_ROLE
+}
+
+export function getAccessAudience(user: PermissionUser | null | undefined): Exclude<AccessAudience, 'all'> {
+  return isAdminUser(user) ? 'admin' : 'user'
+}
+
+export function getUserPermissions(user: PermissionUser | null | undefined): string[] {
+  const rolePermissions = getRoleInfo(user)?.permissions
+  if (rolePermissions?.length) return [...rolePermissions]
+  return [...(user?.permissions ?? [])]
+}
+
+export function hasAllPermissions(
+  user: PermissionUser | null | undefined,
+  permissions: readonly string[] = [],
+): boolean {
+  if (permissions.length === 0) return true
+  if (isAdminUser(user)) return true
+  const granted = new Set(getUserPermissions(user))
+  return permissions.every(permission => granted.has(permission))
+}
+
+export function hasAnyPermission(
+  user: PermissionUser | null | undefined,
+  permissions: readonly string[] = [],
+): boolean {
+  if (permissions.length === 0) return true
+  if (isAdminUser(user)) return true
+  const granted = new Set(getUserPermissions(user))
+  return permissions.some(permission => granted.has(permission))
+}
+
+export function canAccessAdmin(user: PermissionUser | null | undefined): boolean {
+  return isAdminUser(user) || hasAnyPermission(user, ADMIN_PANEL_PERMISSIONS)
+}
+
+export function canAccessPlugin(
+  user: PermissionUser | null | undefined,
+  pluginName: string | null | undefined,
+): boolean {
+  if (!pluginName) return true
+  const access = getRoleInfo(user)?.plugin_access
+  if (!access || access === 'all') return true
+  return Array.isArray(access) && access.includes(pluginName)
+}
+
+export function normalizeAccessPolicy(rule: AccessControlled | AccessPolicy | undefined): AccessPolicy {
+  if (!rule) return {}
+  const { access: nested, ...direct } = rule as AccessPolicy & { access?: AccessPolicy }
+  return {
+    ...(nested ?? {}),
+    ...direct,
+    ...('visibleFor' in rule && rule.visibleFor !== undefined ? { visibleFor: rule.visibleFor } : {}),
+    ...('requiresAdmin' in rule && rule.requiresAdmin !== undefined ? { requiresAdmin: rule.requiresAdmin } : {}),
+    ...('permissions' in rule && rule.permissions !== undefined ? { permissions: rule.permissions } : {}),
+    ...('anyPermissions' in rule && rule.anyPermissions !== undefined ? { anyPermissions: rule.anyPermissions } : {}),
+  }
+}
+
+export function canAccessByPolicy(
+  user: PermissionUser | null | undefined,
+  rule: AccessControlled | AccessPolicy | undefined,
+  isAuthenticated = user !== null && user !== undefined,
+): boolean {
+  const policy = normalizeAccessPolicy(rule)
+  if (policy.requiresAuth && !isAuthenticated) return false
+  if (policy.requiresAdmin && !isAdminUser(user)) return false
+  if (!audienceAllowsUser(policy.visibleFor ?? policy.audience, user)) return false
+  if (!hasAllPermissions(user, policy.permissions)) return false
+  if (!hasAnyPermission(user, policy.anyPermissions)) return false
+  if (policy.plugin && !canAccessPlugin(user, policy.plugin)) return false
+  return true
+}
+
+function audienceAllowsUser(
+  audience: AccessAudienceInput | undefined,
+  user: PermissionUser | null | undefined,
+): boolean {
+  if (audience === undefined) return true
+  const allowed = Array.isArray(audience) ? audience : [audience]
+  if (allowed.includes('all')) return true
+  return allowed.includes(getAccessAudience(user))
+}

package/src/stores/auth.ts

@@ -1,6 +1,15 @@
 import { defineStore } from 'pinia'
 import { ref, computed } from 'vue'
 import type { AuthConfig, UserInfo } from '../types'
+import {
+  canAccessAdmin as canUserAccessAdmin,
+  canAccessPlugin as canUserAccessPlugin,
+  getAccessAudience,
+  getUserPermissions,
+  hasAllPermissions,
+  hasAnyPermission,
+  isAdminUser,
+} from '../permissions'
 
 const AUTH_TOKEN_KEY = 'mint-auth-token'
 const AUTH_EXPIRES_KEY = 'mint-auth-expires'
@@ -73,9 +82,10 @@ export const useAuthStore = defineStore('mint-auth', () => {
     return authConfig.value.authRequired && !isAuthenticated.value
   })
 
-  const isAdmin = computed(() => {
-    return userInfo.value?.role === 'admin'
-  })
+  const isAdmin = computed(() => isAdminUser(userInfo.value))
+  const userType = computed(() => getAccessAudience(userInfo.value))
+  const permissions = computed(() => getUserPermissions(userInfo.value))
+  const canAccessAdmin = computed(() => canUserAccessAdmin(userInfo.value))
 
   const canRegister = computed(() => {
     return authConfig.value.registrationEnabled
@@ -126,6 +136,18 @@ export const useAuthStore = defineStore('mint-auth', () => {
     username.value = info.username
   }
 
+  function hasPermission(...perms: string[]): boolean {
+    return hasAllPermissions(userInfo.value, perms)
+  }
+
+  function hasAnyPermissionForUser(...perms: string[]): boolean {
+    return hasAnyPermission(userInfo.value, perms)
+  }
+
+  function canAccessPlugin(pluginName: string): boolean {
+    return canUserAccessPlugin(userInfo.value, pluginName)
+  }
+
   function setAuthConfig(config: AuthConfig) {
     authConfig.value = config
   }
@@ -161,6 +183,9 @@ export const useAuthStore = defineStore('mint-auth', () => {
     isAuthenticated,
     needsAuth,
     isAdmin,
+    userType,
+    permissions,
+    canAccessAdmin,
     canRegister,
 
     // Actions
@@ -172,6 +197,9 @@ export const useAuthStore = defineStore('mint-auth', () => {
     setUserInfo,
     setError,
     setLoading,
+    hasPermission,
+    hasAnyPermission: hasAnyPermissionForUser,
+    canAccessPlugin,
     logout,
   }
 })