@quazardous/qdadm 2.4.3 → 2.4.5

package/src/composables/useListPage.ts

@@ -33,7 +33,6 @@ import { useConfirm } from 'primevue/useconfirm'
 import { useHooks } from './useHooks.js'
 import { useEntityItemPage, type ParentConfig, type UseEntityItemPageReturn } from './useEntityItemPage.js'
 import { useActiveStack } from '../chain/useActiveStack.js'
-import { FilterQuery } from '../query/FilterQuery'
 import { useI18n } from '../i18n/useI18n'
 import { formatDateOnly } from '../utils/formatters'
 
@@ -85,17 +84,15 @@ export type {
 // Stateless utilities (cookies, session storage, formatters, constants).
 import {
   PAGE_SIZE_OPTIONS,
-  SMART_FILTER_THRESHOLD,
-  clearSessionFilters,
   getSavedPageSize,
   getSessionFilters,
   getSessionSort,
   setSessionSort,
   persistPageSize,
-  setSessionFilters,
-  snakeToTitle,
 } from './useListPage.utils'
 import { useActionRegistry } from './useActionRegistry'
+import { useListFilters } from './useListPage.filters'
+import { useListAlterHooks } from './useListPage.alterHooks'
 import { useOrchestrator } from '../orchestrator/useOrchestrator.js'
 import { createOrchestratorToast } from './useOrchestratorToast'
 
@@ -514,323 +511,45 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
 
   const cards = computed(() => Array.from(cardsMap.value.values()))
 
-  // ============ FILTERS ============
-  const filtersMap = ref<Map<string, FilterConfig>>(new Map())
-  const filterValues = ref<Record<string, unknown>>(savedFilters || {})
-
-  function addFilter(name: string, filterConfig: Omit<FilterConfig, 'name'>): void {
-    filtersMap.value.set(name, {
-      name,
-      type: 'select',
-      placeholder: name,
-      ...filterConfig,
-    })
-    if (filterValues.value[name] === undefined) {
-      filterValues.value[name] = filterConfig.default ?? null
-    }
-  }
-
-  function removeFilter(name: string): void {
-    filtersMap.value.delete(name)
-    delete filterValues.value[name]
-  }
-
-  function setFilterValue(name: string, value: unknown): void {
-    filterValues.value = { ...filterValues.value, [name]: value }
-  }
-
-  function updateFilters(newValues: Record<string, unknown>): void {
-    filterValues.value = { ...filterValues.value, ...newValues }
-    onFiltersChanged()
-  }
-
-  function onFiltersChanged(): void {
-    page.value = 1
-    loadItems()
-    if (persistFilters) {
-      const toPersist: Record<string, unknown> = {}
-      for (const [name, value] of Object.entries(filterValues.value)) {
-        const filterDef = filtersMap.value.get(name)
-        if (
-          filterDef?.persist !== false &&
-          value !== null &&
-          value !== undefined &&
-          value !== ''
-        ) {
-          toPersist[name] = value
-        }
-      }
-      if (searchQuery.value) {
-        toPersist._search = searchQuery.value
-      }
-      setSessionFilters(filterSessionKey, toPersist)
-    }
-    if (syncUrlParams) {
-      const query = { ...route.query } as Record<string, string>
-      for (const [name, value] of Object.entries(filterValues.value)) {
-        if (value !== null && value !== undefined && value !== '') {
-          query[name] = String(value)
-        } else {
-          delete query[name]
-        }
-      }
-      if (searchQuery.value) {
-        query.search = searchQuery.value
-      } else {
-        delete query.search
-      }
-      router.replace({ query })
-    }
-  }
-
-  function clearFilters(): void {
-    const cleared: Record<string, unknown> = {}
-    for (const [key, filterDef] of filtersMap.value.entries()) {
-      cleared[key] = filterDef.default ?? null
-    }
-    filterValues.value = cleared
-    searchQuery.value = ''
-    if (persistFilters) {
-      clearSessionFilters(filterSessionKey)
-    }
-    if (syncUrlParams) {
-      const query = { ...route.query } as Record<string, string>
-      for (const key of filtersMap.value.keys()) {
-        delete query[key]
-      }
-      delete query.search
-      router.replace({ query })
-    }
-    page.value = 1
-    loadItems()
-  }
-
-  const filters = computed(() => Array.from(filtersMap.value.values()))
-
-  /**
-   * Check if a filter is at its default value
-   * Used for styling: default = blue (info), modified = orange (warning)
-   */
-  function isFilterAtDefault(name: string): boolean {
-    const filterDef = filtersMap.value.get(name)
-    if (!filterDef) return true
-    const currentValue = filterValues.value[name]
-    const defaultValue = filterDef.default ?? null
-    return currentValue === defaultValue
-  }
-
-  /**
-   * Check if any filter is NOT at its default value (or search is active)
-   * Useful to show a "clear filters" button only when needed
-   */
-  const hasActiveFilters = computed(() => {
-    if (searchQuery.value) return true
-    for (const [name, filterDef] of filtersMap.value.entries()) {
-      const currentValue = filterValues.value[name]
-      const defaultValue = filterDef.default ?? null
-      if (currentValue !== defaultValue) return true
-    }
-    return false
+  // ============ FILTERS (#1195 — extracted subsystem) ============
+  // invokeFilterAlterHook is a thunk: alterHooks is declared after the
+  // actions section (it needs the action registry) and only runs post-setup.
+  const listFilters = useListFilters({
+    entityName,
+    manager,
+    orchestrator,
+    items: items as Ref<unknown[]>,
+    page,
+    searchQuery,
+    route,
+    router,
+    savedFilters,
+    persistFilters,
+    syncUrlParams,
+    autoLoadFilters,
+    filterSessionKey,
+    entityFilters,
+    loadItems: () => loadItems(),
+    setSearch: (searchCfg) => setSearch(searchCfg),
+    invokeFilterAlterHook: () => alterHooks.invokeFilterAlterHook(),
   })
-
-  // ============ AUTO-LOAD FROM REGISTRY ============
-
-  function initFromRegistry(): void {
-    if (!autoLoadFilters) return
-
-    const entityConfig = entityFilters[entityName]
-    if (!entityConfig) return
-
-    if (entityConfig.search) {
-      setSearch(entityConfig.search)
-    }
-
-    if (entityConfig.filters) {
-      for (const filterDef of entityConfig.filters) {
-        addFilter(filterDef.name, filterDef)
-      }
-    }
-  }
-
-  async function loadFilterOptions(): Promise<void> {
-    // Process filters configured directly via addFilter() (smart filter modes)
-    for (const [filterName, filterDef] of filtersMap.value) {
-      if (filterDef.options && filterDef.options.length > 1) continue
-      if (filterDef.optionsFromCache) continue
-
-      try {
-        let rawOptions: Array<{ label: string; value: unknown }> | null = null
-
-        // Mode 1: optionsEntity - fetch from related EntityManager via FilterQuery
-        if (filterDef.optionsEntity) {
-          const filterQuery = new FilterQuery({
-            source: 'entity',
-            entity: filterDef.optionsEntity,
-            label: filterDef.optionLabel || 'name',
-            value: filterDef.optionValue || 'id',
-          })
-
-          rawOptions = (await filterQuery.getOptions(orchestrator)) as Array<{
-            label: string
-            value: unknown
-          }>
-          filterDef._filterQuery = filterQuery
-        }
-        // Mode 2: optionsEndpoint - fetch from API endpoint
-        else if (filterDef.optionsEndpoint) {
-          const endpoint =
-            filterDef.optionsEndpoint === true
-              ? `distinct/${filterName}`
-              : filterDef.optionsEndpoint
-          const response = await manager.request('GET', endpoint as string)
-          const data = Array.isArray(response)
-            ? response
-            : ((response as Record<string, unknown>)?.items as unknown[]) || []
-          rawOptions = data.map((opt) => {
-            if (typeof opt === 'object' && opt !== null) {
-              const o = opt as Record<string, unknown>
-              return {
-                label: (o.label || o.name || String(o.value ?? o.id)) as string,
-                value: o.value ?? o.id,
-              }
-            }
-            return { label: snakeToTitle(String(opt)), value: opt }
-          })
-        }
-
-        if (rawOptions !== null) {
-          const cacheOptions = filterDef.cacheOptions ?? 'auto'
-          let shouldCache = cacheOptions === true
-
-          if (cacheOptions === 'auto') {
-            shouldCache = rawOptions.length <= SMART_FILTER_THRESHOLD
-          }
-
-          const componentType =
-            filterDef.component || (shouldCache ? 'dropdown' : 'autocomplete')
-          const allLabel =
-            filterDef.allLabel || filterDef.placeholder || `All ${snakeToTitle(filterName)}`
-          let finalOptions = [{ label: allLabel, value: null as unknown }, ...rawOptions]
-
-          if (typeof filterDef.processor === 'function') {
-            finalOptions = filterDef.processor(finalOptions)
-          }
-
-          const updatedFilter: FilterConfig = {
-            ...filterDef,
-            options: finalOptions,
-            type: componentType,
-            _cacheOptions: shouldCache,
-            _optionsLoaded: shouldCache,
-          }
-          delete updatedFilter.optionLabel
-          delete updatedFilter.optionValue
-          filtersMap.value.set(filterName, updatedFilter)
-        }
-      } catch (error) {
-        console.warn(`[qdadm] Failed to load options for filter "${filterName}":`, error)
-      }
-    }
-
-    // Invoke filter:alter hooks after all options are loaded
-    await invokeFilterAlterHook()
-
-    // Trigger Vue reactivity
-    filtersMap.value = new Map(filtersMap.value)
-  }
-
-  async function updateCacheBasedFilters(): Promise<void> {
-    if (items.value.length === 0) return
-
-    let hasChanges = false
-
-    for (const [filterName, filterDef] of filtersMap.value) {
-      if (!filterDef.optionsFromCache) continue
-      if (filterDef._optionsLoaded) continue
-      // Skip if filter has an explicit query property (advanced usage)
-      if (filterDef.query) continue
-
-      const currentValue = filterValues.value[filterName]
-      if (currentValue !== null && currentValue !== undefined && currentValue !== '') {
-        continue
-      }
-
-      const fieldName =
-        typeof filterDef.optionsFromCache === 'string' ? filterDef.optionsFromCache : filterName
-
-      const filterQuery = new FilterQuery({
-        source: 'field',
-        field: fieldName,
-      })
-
-      // Provide a minimal mock manager with cached data for field-based filtering
-      filterQuery.setParentManager({
-        _cache: items.value,
-        list: async () => ({ items: items.value }),
-      })
-
-      const rawOptions = (await filterQuery.getOptions()) as Array<{ label: string; value: unknown }>
-
-      const cacheOptions = filterDef.cacheOptions ?? 'auto'
-      let shouldCache = true
-
-      if (cacheOptions === 'auto') {
-        shouldCache = rawOptions.length <= SMART_FILTER_THRESHOLD
-      } else if (cacheOptions === false) {
-        shouldCache = false
-      }
-
-      const componentType =
-        filterDef.component ||
-        (rawOptions.length <= SMART_FILTER_THRESHOLD ? 'dropdown' : 'autocomplete')
-
-      const allLabel =
-        filterDef.allLabel || filterDef.placeholder || `All ${snakeToTitle(filterName)}`
-      let finalOptions = [
-        { label: allLabel, value: null as unknown },
-        ...rawOptions.map((opt) => ({
-          label: snakeToTitle(String(opt.label)),
-          value: opt.value,
-        })),
-      ]
-
-      if (typeof filterDef.processor === 'function') {
-        finalOptions = filterDef.processor(finalOptions)
-      }
-
-      const updatedFilter: FilterConfig = {
-        ...filterDef,
-        options: finalOptions,
-        type: componentType,
-        _cacheOptions: shouldCache,
-        _optionsLoaded: true,
-        _filterQuery: filterQuery,
-      }
-
-      filtersMap.value.set(filterName, updatedFilter)
-      hasChanges = true
-    }
-
-    if (hasChanges) {
-      filtersMap.value = new Map(filtersMap.value)
-    }
-  }
-
-  function restoreFilters(): void {
-    for (const key of filtersMap.value.keys()) {
-      if (route.query[key] !== undefined) {
-        let value: unknown = route.query[key]
-        if (value === 'true') value = true
-        else if (value === 'false') value = false
-        else if (value === 'null') value = null
-        else if (!isNaN(Number(value)) && value !== '') value = Number(value)
-        filterValues.value[key] = value
-      }
-    }
-    if (route.query.search) {
-      searchQuery.value = route.query.search as string
-    }
-  }
+  const {
+    filtersMap,
+    filterValues,
+    filters,
+    hasActiveFilters,
+    addFilter,
+    removeFilter,
+    setFilterValue,
+    updateFilters,
+    onFiltersChanged,
+    clearFilters,
+    isFilterAtDefault,
+    initFromRegistry,
+    loadFilterOptions,
+    updateCacheBasedFilters,
+    restoreFilters,
+  } = listFilters
 
   // ============ ACTIONS ============
   function resolveValue<T>(value: T | ((row: unknown) => T), row: unknown): T {
@@ -852,7 +571,6 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
       }
     },
   })
-  const actionsMap = actionRegistry.actionsMap
 
   function addAction(name: string, actionConfig: Omit<ActionConfig, 'name'>): void {
     actionRegistry.add({ name, ...actionConfig } as ActionConfig)
@@ -1215,96 +933,18 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
     }
   })
 
-  // ============ HOOKS ============
-
-  async function invokeListAlterHook(): Promise<void> {
-    if (!hooks) return
-
-    const configSnapshot = {
-      entity,
-      columns: Array.from(columnsMap.value.values()),
-      filters: Array.from(filtersMap.value.values()),
-      actions: Array.from(actionsMap.value.values()),
-      headerActions: Array.from(headerActionsMap.value.values()),
-    }
-
-    // Include entity context in the snapshot for hooks
-    const configWithContext = { ...configSnapshot, entity, manager }
-
-    let alteredConfig = await hooks.alter('list:alter', configWithContext)
-
-    const entityHookName = `${entity}:list:alter`
-    if (hooks.hasHook(entityHookName)) {
-      alteredConfig = await hooks.alter(entityHookName, alteredConfig)
-    }
-
-    applyAlteredConfig(alteredConfig)
-  }
-
-  async function invokeFilterAlterHook(): Promise<void> {
-    if (!hooks) return
-
-    const filterSnapshot = {
-      entity,
-      filters: Array.from(filtersMap.value.values()),
-    }
-
-    let alteredFilters = (await hooks.alter('filter:alter', filterSnapshot)) as typeof filterSnapshot
-
-    const entityHookName = `${entity}:filter:alter`
-    if (hooks.hasHook(entityHookName)) {
-      alteredFilters = (await hooks.alter(entityHookName, alteredFilters)) as typeof filterSnapshot
-    }
-
-    if (alteredFilters.filters) {
-      filtersMap.value.clear()
-      for (const filter of alteredFilters.filters) {
-        filtersMap.value.set(filter.name, filter)
-        if (filterValues.value[filter.name] === undefined) {
-          filterValues.value[filter.name] = filter.default ?? null
-        }
-      }
-    }
-  }
-
-  function applyAlteredConfig(alteredConfig: {
-    columns?: ColumnConfig[]
-    filters?: FilterConfig[]
-    actions?: ActionConfig[]
-    headerActions?: HeaderActionConfig[]
-  }): void {
-    if (alteredConfig.columns) {
-      columnsMap.value.clear()
-      for (const col of alteredConfig.columns) {
-        columnsMap.value.set(col.field, col)
-      }
-    }
-
-    if (alteredConfig.filters) {
-      filtersMap.value.clear()
-      for (const filter of alteredConfig.filters) {
-        filtersMap.value.set(filter.name, filter)
-        if (filterValues.value[filter.name] === undefined) {
-          filterValues.value[filter.name] = filter.default ?? null
-        }
-      }
-    }
-
-    if (alteredConfig.actions) {
-      // Route through the registry so the order list stays in sync (#1193)
-      actionRegistry.clear()
-      for (const action of alteredConfig.actions) {
-        actionRegistry.add(action)
-      }
-    }
-
-    if (alteredConfig.headerActions) {
-      headerActionsMap.value.clear()
-      for (const action of alteredConfig.headerActions) {
-        headerActionsMap.value.set(action.name, action)
-      }
-    }
-  }
+  // ============ HOOKS (#1195 — extracted subsystem) ============
+  const alterHooks = useListAlterHooks({
+    hooks,
+    entity,
+    manager,
+    columnsMap,
+    filtersMap,
+    filterValues,
+    headerActionsMap,
+    actionRegistry,
+  })
+  const { invokeListAlterHook } = alterHooks
 
   // ============ LIFECYCLE ============
   initFromRegistry()

package/src/entity/EntityManager.ts

@@ -501,10 +501,7 @@ export class EntityManager<T extends EntityRecord = EntityRecord> {
    * Check if SecurityChecker is configured via authAdapter
    */
   protected _hasSecurityChecker(): boolean {
-    return (
-      (this.authAdapter as unknown as { _securityChecker?: unknown })
-        ?._securityChecker != null
-    )
+    return this.authAdapter?.hasSecurityChecker?.() ?? false
   }
 
   /**

package/src/entity/auth/EntityAuthAdapter.ts

@@ -41,6 +41,16 @@ export class EntityAuthAdapter {
     this._securityChecker = checker
   }
 
+  /**
+   * Whether a SecurityChecker is configured (#1196).
+   *
+   * Public capability probe — EntityManager used to reach into the
+   * private _securityChecker field through a cast.
+   */
+  hasSecurityChecker(): boolean {
+    return this._securityChecker != null
+  }
+
   /**
    * Check if current user is granted an attribute (Symfony-like contract)
    *

package/src/entity/auth/SecurityChecker.ts

@@ -52,28 +52,24 @@ export interface SecurityCheckerConfig {
  */
 export class SecurityChecker {
   protected _rolesProvider: RoleProvider
-  protected _legacyRoleHierarchy: RoleHierarchy | null
   readonly getCurrentUser: () => AuthUser | null
 
   constructor({ rolesProvider, roleHierarchy, rolePermissions, getCurrentUser }: SecurityCheckerOptions) {
-    // Support both new rolesProvider and legacy rolePermissions
     if (rolesProvider) {
       this._rolesProvider = rolesProvider
-      this._legacyRoleHierarchy = null
     } else {
-      // Legacy: create static provider from rolePermissions
+      // Legacy options (roleHierarchy/rolePermissions) are normalized ONCE
+      // into a static provider (#1196) — the parallel _legacyRoleHierarchy
+      // branch is gone; only the provider path remains.
       const hierarchyConfig =
-        roleHierarchy instanceof RoleHierarchy ? {} : (roleHierarchy as RoleHierarchyConfig) || {}
+        roleHierarchy instanceof RoleHierarchy
+          ? roleHierarchy.map
+          : (roleHierarchy as RoleHierarchyConfig) || {}
 
       this._rolesProvider = new StaticRoleProvider({
         role_hierarchy: hierarchyConfig,
         role_permissions: rolePermissions || {},
       })
-
-      this._legacyRoleHierarchy =
-        roleHierarchy instanceof RoleHierarchy
-          ? roleHierarchy
-          : new RoleHierarchy(hierarchyConfig)
     }
 
     this.getCurrentUser = getCurrentUser
@@ -83,9 +79,6 @@ export class SecurityChecker {
    * Get role hierarchy (dynamically resolved from rolesProvider)
    */
   get roleHierarchy(): RoleHierarchy {
-    if (this._legacyRoleHierarchy) {
-      return this._legacyRoleHierarchy
-    }
     return new RoleHierarchy(this._rolesProvider.getHierarchy())
   }
 

package/src/kernel/Kernel.api.ts

@@ -1,14 +1,14 @@
 import type { AxiosLikeClient, AxiosError } from './Kernel.types'
+import type { Kernel } from './Kernel'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with API client methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyApiMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyApiMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Setup an axios client with automatic auth and error handling

package/src/kernel/Kernel.auth.ts

@@ -1,14 +1,14 @@
 import { authFactory, CompositeAuthAdapter } from '../entity/auth'
+import type { Kernel } from './Kernel'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with auth-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyAuthMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyAuthMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Resolve entityAuthAdapter through authFactory

package/src/kernel/Kernel.i18n.ts

@@ -9,13 +9,13 @@
 
 import { I18n } from '../i18n/I18n'
 import type { I18nOptions } from '../i18n/types'
+import type { Kernel } from './Kernel'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyI18nMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyI18nMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   proto._createI18n = function (this: Self): void {
     const opts = (this.options.i18n as I18nOptions | undefined) ?? {}

package/src/kernel/Kernel.modules.ts

@@ -1,15 +1,15 @@
 import { initModules, setSectionOrder } from '../module/moduleRegistry'
 import { createModuleLoader, type ModuleLike } from './ModuleLoader'
 import { createKernelContext, type KernelContext } from './KernelContext'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+import type { Kernel } from './Kernel'
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with module-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyModuleMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyModuleMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Fire entity cache warmups

package/src/kernel/Kernel.registries.ts

@@ -13,15 +13,15 @@ import { ActiveStack } from '../chain/ActiveStack.js'
 import { StackHydrator } from '../chain/StackHydrator.js'
 import { Orchestrator } from '../orchestrator/Orchestrator'
 import type { EntityAuthAdapter } from '../entity/auth/EntityAuthAdapter'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+import type { Kernel } from './Kernel'
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with registry-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyRegistryMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyRegistryMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Create signal bus for event-driven communication.