@quazardous/qdadm 1.19.3

package/src/kernel/Kernel.i18n.ts

@@ -0,0 +1,29 @@
+/**
+ * Patch Kernel prototype with i18n-related methods.
+ *
+ * Adds:
+ *   - kernel.i18n  : I18n instance
+ *   - _createI18n() : init step
+ *   - _bootstrapI18n() : warmup step (loads default + fallback locales)
+ */
+
+import { I18n } from '../i18n/I18n'
+import type { I18nOptions } from '../i18n/types'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Self = any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function applyI18nMethods(KernelClass: { prototype: any }): void {
+  const proto = KernelClass.prototype as Self
+
+  proto._createI18n = function (this: Self): void {
+    const opts = (this.options.i18n as I18nOptions | undefined) ?? {}
+    this.i18nInstance = new I18n(opts, { signals: this.signals })
+  }
+
+  proto._bootstrapI18n = function (this: Self): Promise<void> {
+    if (!this.i18nInstance) return Promise.resolve()
+    return this.i18nInstance.bootstrap()
+  }
+}

package/src/kernel/Kernel.modules.ts

@@ -0,0 +1,170 @@
+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
+
+/**
+ * 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
+
+  /**
+   * Fire entity cache warmups
+   */
+  proto._fireWarmups = function (this: Self): void {
+    if (this.i18nInstance) {
+      // Fire-and-forget bootstrap; locale-sensitive pages await
+      // 'i18n:locale:{loc}:ready' via DeferredRegistry if needed.
+      void this._bootstrapI18n()
+    }
+
+    const warmup = this.options.warmup ?? true
+    if (!warmup) return
+
+    this.orchestrator!.fireWarmups()
+  }
+
+  /**
+   * Initialize legacy modules from glob import
+   */
+  proto._initModules = function (this: Self): void {
+    if (this.options.sectionOrder) {
+      setSectionOrder(this.options.sectionOrder)
+    }
+    if (this.options.modules) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      initModules(this.options.modules as any, {
+        ...this.options.modulesOptions,
+        zones: this.zoneRegistry,
+        signals: this.signals,
+        hooks: this.hookRegistry,
+        deferred: this.deferred,
+      } as any)
+    }
+  }
+
+  /**
+   * Create KernelContext for module connection
+   */
+  proto._createModuleContext = function (this: Self, module: ModuleLike): KernelContext {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return createKernelContext(this as any, module as any)
+  }
+
+  /**
+   * Load new-style modules synchronously
+   */
+  proto._loadModulesSync = function (this: Self): void {
+    const { moduleDefs } = this.options
+    if (!moduleDefs?.length) return
+
+    this.moduleLoader = createModuleLoader()
+
+    for (const mod of moduleDefs) {
+      this.moduleLoader.add(mod as ModuleLike)
+    }
+
+    // Access private method for sorting
+    const sorted = (this.moduleLoader as unknown as { _topologicalSort(): string[] })._topologicalSort()
+    const registered = (this.moduleLoader as unknown as { _registered: Map<string, ModuleLike> })._registered
+    const loaded = (this.moduleLoader as unknown as { _loaded: Map<string, ModuleLike> })._loaded
+    const loadOrder = (this.moduleLoader as unknown as { _loadOrder: string[] })._loadOrder
+
+    for (const name of sorted) {
+      const module = registered.get(name)
+      if (!module) continue
+
+      const ctx = this._createModuleContext(module)
+
+      if (!module.enabled(ctx as unknown as Parameters<typeof module.enabled>[0])) {
+        continue
+      }
+
+      if (typeof module.loadStyles === 'function') {
+        const styleResult = module.loadStyles()
+        if (styleResult instanceof Promise) {
+          styleResult.catch((err) => {
+            console.warn(`[Kernel] Module '${name}' styles failed:`, err)
+          })
+        }
+      }
+
+      const result = module.connect(ctx as unknown as Parameters<typeof module.connect>[0])
+
+      if (result instanceof Promise) {
+        result.catch((err) => {
+          console.error(`[Kernel] Async module '${name}' failed:`, err)
+        })
+      }
+
+      loaded.set(name, module)
+      loadOrder.push(name)
+    }
+  }
+
+  /**
+   * Load new-style modules asynchronously
+   */
+  proto._loadModules = async function (this: Self): Promise<void> {
+    const { moduleDefs } = this.options
+    if (!moduleDefs?.length) return
+
+    this.moduleLoader = createModuleLoader()
+
+    for (const mod of moduleDefs) {
+      this.moduleLoader.add(mod as ModuleLike)
+    }
+
+    const sorted = (this.moduleLoader as unknown as { _topologicalSort(): string[] })._topologicalSort()
+    const registered = (this.moduleLoader as unknown as { _registered: Map<string, ModuleLike> })._registered
+    const loaded = (this.moduleLoader as unknown as { _loaded: Map<string, ModuleLike> })._loaded
+    const loadOrder = (this.moduleLoader as unknown as { _loadOrder: string[] })._loadOrder
+
+    for (const name of sorted) {
+      const module = registered.get(name)
+      if (!module) continue
+
+      const ctx = this._createModuleContext(module)
+
+      if (!module.enabled(ctx as unknown as Parameters<typeof module.enabled>[0])) {
+        continue
+      }
+
+      if (typeof module.loadStyles === 'function') {
+        await module.loadStyles()
+      }
+
+      await module.connect(ctx as unknown as Parameters<typeof module.connect>[0])
+
+      loaded.set(name, module)
+      loadOrder.push(name)
+    }
+  }
+
+  /**
+   * Wire modules that need orchestrator (phase 2)
+   */
+  proto._wireModules = function (this: Self): void {
+    if (!this.moduleLoader) return
+
+    const result = this.signals!.emit('kernel:ready', { ready: true })
+
+    if (result instanceof Promise) {
+      result.catch((err) => {
+        console.error('[Kernel] kernel:ready handler failed:', err)
+      })
+    }
+  }
+
+  /**
+   * Wire modules that need orchestrator (phase 2) - async version
+   */
+  proto._wireModulesAsync = async function (this: Self): Promise<void> {
+    if (!this.moduleLoader) return
+
+    await this.signals!.emit('kernel:ready', { ready: true })
+  }
+}

package/src/kernel/Kernel.registries.ts

@@ -0,0 +1,237 @@
+import { createSignalBus } from './SignalBus'
+import { createZoneRegistry } from '../zones/ZoneRegistry'
+import { createHookRegistry } from '../hooks/HookRegistry'
+import { createSecurityChecker } from '../entity/auth/SecurityChecker'
+import { PermissionRegistry } from '../security/PermissionRegistry'
+import { StaticRoleProvider } from '../security/StaticRolesProvider'
+import { createManagers, type ManagerFactoryContext } from '../entity/factory.js'
+import { defaultStorageResolver } from '../entity/storage/factory'
+import { createDeferredRegistry } from '../deferred/DeferredRegistry.js'
+import { createEventRouter } from './EventRouter'
+import { createSSEBridge } from './SSEBridge'
+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
+
+/**
+ * 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
+
+  /**
+   * Create signal bus for event-driven communication.
+   *
+   * When `options.existingSignals` is provided (host shell already
+   * owns a bus), reuse it instead of spinning up a fresh one. This
+   * is what lets qdcms and qdadm share entity events when they're
+   * mounted on the same Vue app.
+   */
+  proto._createSignalBus = function (this: Self): void {
+    if (this.options.existingSignals) {
+      this.signals = this.options.existingSignals
+      return
+    }
+    const debug = this.options.debug ?? false
+    this.signals = createSignalBus({ debug })
+  }
+
+  /**
+   * Create hook registry for Drupal-inspired extensibility
+   */
+  proto._createHookRegistry = function (this: Self): void {
+    const debug = this.options.debug ?? false
+    this.hookRegistry = createHookRegistry({
+      kernel: this.signals!.getKernel(),
+      debug,
+    })
+  }
+
+  /**
+   * Create orchestrator with managers and signal bus
+   */
+  proto._createOrchestrator = function (this: Self): void {
+    const factoryContext = {
+      storageResolver: this.options.storageResolver || defaultStorageResolver,
+      managerResolver: this.options.managerResolver,
+      managerRegistry: this.options.managerRegistry || {},
+    } as ManagerFactoryContext
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const managers = createManagers((this.options.managers || {}) as any, factoryContext)
+
+    this.orchestrator = new Orchestrator({
+      managers,
+      signals: this.signals,
+      hooks: this.hookRegistry,
+      deferred: this.deferred,
+      entityAuthAdapter: (this.options.entityAuthAdapter as EntityAuthAdapter) || null,
+    })
+
+    // Pass kernel options to orchestrator (avoid circular reference for Vue reactivity)
+    this.orchestrator.kernelOptions = {
+      defaultEntityCacheTtlMs: this.options.defaultEntityCacheTtlMs,
+    }
+
+    if (this.options.toast) {
+      this.orchestrator.setToastConfig(this.options.toast)
+    }
+  }
+
+  /**
+   * Create PermissionRegistry early so modules can register permissions
+   */
+  proto._createPermissionRegistry = function (this: Self): void {
+    this.permissionRegistry = new PermissionRegistry()
+    this._registerCorePermissions()
+  }
+
+  /**
+   * Register core system permissions provided by the framework
+   */
+  proto._registerCorePermissions = function (this: Self): void {
+    this.permissionRegistry!.register('auth', {
+      impersonate: 'Impersonate other users',
+      manage: 'Manage authentication settings',
+    })
+
+    this.permissionRegistry!.register('admin', {
+      access: 'Access admin panel',
+      config: 'Edit system configuration',
+    })
+  }
+
+  /**
+   * Setup security layer (role hierarchy, permissions)
+   */
+  proto._setupSecurity = function (this: Self): void {
+    const { security, entityAuthAdapter } = this.options
+
+    if (!this.permissionRegistry) {
+      this.permissionRegistry = new PermissionRegistry()
+    }
+
+    if (!security) return
+
+    let rolesProvider = security.rolesProvider
+    if (!rolesProvider && (security.role_permissions || security.role_hierarchy)) {
+      rolesProvider = new StaticRoleProvider({
+        role_hierarchy: security.role_hierarchy || {},
+        role_permissions: security.role_permissions || {},
+        role_labels: security.role_labels || {},
+      })
+    }
+
+    this.securityChecker = createSecurityChecker({
+      rolesProvider: rolesProvider || undefined,
+      getCurrentUser: () =>
+        (entityAuthAdapter as EntityAuthAdapter | null)?.getCurrentUser?.() || null,
+    })
+
+    // Store entity_permissions config (augment securityChecker for EntityManager to use)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(this.securityChecker as any).entityPermissions = security.entity_permissions ?? false
+
+    const adapter = entityAuthAdapter as EntityAuthAdapter | null
+    if (adapter?.setSecurityChecker) {
+      adapter.setSecurityChecker(this.securityChecker)
+    }
+
+    if (rolesProvider?.install) {
+      const ctx = {
+        orchestrator: this.orchestrator,
+        signals: this.signals,
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      rolesProvider.install(ctx as any)
+    }
+  }
+
+  /**
+   * Create zone registry for extensible UI composition
+   */
+  proto._createZoneRegistry = function (this: Self): void {
+    const debug = this.options.debug ?? false
+    this.zoneRegistry = createZoneRegistry({ debug })
+  }
+
+  /**
+   * Create active stack for navigation state
+   */
+  proto._createActiveStack = function (this: Self): void {
+    this.activeStack = new ActiveStack(this.signals!)
+  }
+
+  /**
+   * Create stack hydrator for async data loading
+   */
+  proto._createStackHydrator = function (this: Self): void {
+    this.stackHydrator = new StackHydrator(
+      this.activeStack!,
+      this.orchestrator!,
+      this.signals!
+    )
+  }
+
+  /**
+   * Create deferred registry for async service loading
+   */
+  proto._createDeferredRegistry = function (this: Self): void {
+    const debug = this.options.debug ?? false
+    this.deferred = createDeferredRegistry({
+      kernel: this.signals?.getKernel() || null,
+      debug,
+    })
+  }
+
+  /**
+   * Create EventRouter for declarative signal routing
+   */
+  proto._createEventRouter = function (this: Self): void {
+    const { eventRouter: routes } = this.options
+    if (!routes || Object.keys(routes).length === 0) return
+
+    const debug = this.options.debug ?? false
+    this.eventRouter = createEventRouter({
+      signals: this.signals!,
+      routes,
+      debug,
+    })
+  }
+
+  /**
+   * Create SSEBridge for Server-Sent Events to SignalBus integration
+   */
+  proto._createSSEBridge = function (this: Self): void {
+    const { sse, authAdapter } = this.options
+    if (!sse?.url) return
+
+    const debug = this.options.debug ?? false
+
+    const getToken = authAdapter?.getToken
+      ? () => authAdapter.getToken!()
+      : () => localStorage.getItem('auth_token')
+
+    this.sseBridge = createSSEBridge({
+      signals: this.signals!,
+      url: sse.url,
+      reconnectDelay: sse.reconnectDelay ?? 5000,
+      signalPrefix: sse.signalPrefix ?? 'sse',
+      autoConnect: sse.autoConnect ?? false,
+      withCredentials: sse.withCredentials ?? false,
+      tokenParam: sse.tokenParam ?? 'token',
+      getToken,
+      debug,
+    })
+
+    if (sse.events?.length) {
+      this.signals!.once('sse:connected', () => {
+        this.sseBridge!.registerEvents(sse.events!)
+      })
+    }
+  }
+}