@dbs-portal/core-module-registry

Core module registry system for automatic module discovery and registration in the DBS Portal framework.

Features

• 🔍 Automatic Module Discovery - Discovers modules from packages, configs, and runtime registration
• 📝 Module Metadata Management - Complete module metadata schema with validation
• ⚡ High-Performance Caching - Built-in caching system with TTL and memory management
• 🎯 Event-Driven Architecture - Real-time notifications for module changes
• 🔒 Permission Integration - Built-in permission and role-based filtering
• 📊 Statistics & Monitoring - Comprehensive stats and performance monitoring
• 🛡️ TypeScript-First - Full TypeScript support with strict typing
• 🌐 Universal Compatibility - Works in both browser and Node.js environments

Installation

yarn add @dbs-portal/core-module-registry

Quick Start

import { ModuleRegistry } from '@dbs-portal/core-module-registry'

// Initialize registry
const registry = ModuleRegistry.getInstance()
await registry.initialize()

// Get all active modules
const modules = registry.getActiveModules()
console.log(`Found ${modules.length} active modules`)

// Register a new module
await registry.registerModule({
  id: 'my-module',
  name: 'My Module',
  version: '1.0.0',
  description: 'A sample module',
  category: 'business',
  icon: 'AppstoreOutlined',
  permissions: ['MyModule.View'],
  routes: [{
    path: '/my-module',
    component: 'MyModulePage'
  }],
  navigation: [{
    key: '/my-module',
    label: 'My Module',
    icon: 'AppstoreOutlined',
    path: '/my-module',
    category: 'business',
    order: 1
  }],
  dependencies: [],
  status: 'active',
  priority: 100,
  author: 'Your Name',
  license: 'MIT'
})

Module Configuration

Create a module.config.ts file in your module directory:

import { ModuleMetadata, ModuleCategory } from '@dbs-portal/core-module-registry'

export const moduleConfig: ModuleMetadata = {
  id: 'file-management',
  name: 'File Management',
  version: '1.0.0',
  description: 'Comprehensive file management system',
  category: ModuleCategory.CONTENT,
  icon: 'FileOutlined',
  permissions: ['FileManagement.View', 'FileManagement.Upload'],
  routes: [
    {
      path: '/files',
      component: 'FileManagementPage',
      permissions: ['FileManagement.View']
    }
  ],
  navigation: [
    {
      key: '/files',
      label: 'File Management',
      icon: 'FileOutlined',
      path: '/files',
      category: 'content',
      order: 1
    }
  ],
  dependencies: ['@dbs-portal/core-ui'],
  status: 'active',
  priority: 100,
  author: 'DBS Portal Team',
  license: 'MIT'
}

API Reference

ModuleRegistry

The main registry class for managing modules.

Methods

• getInstance(options?) - Get singleton instance
• initialize() - Initialize with automatic discovery
• registerModule(metadata, source?) - Register a module
• unregisterModule(moduleId) - Unregister a module
• getModule(moduleId) - Get specific module
• getAllModules() - Get all modules
• getActiveModules() - Get active modules only
• getModulesByCategory(category) - Get modules by category
• searchModules(query) - Search modules
• addListener(listener) - Add event listener

Events

interface RegistryListener {
  onModuleRegistered?(module: ModuleMetadata): void
  onModuleUnregistered?(module: ModuleMetadata): void
  onModuleUpdated?(module: ModuleMetadata): void
  onRegistryInitialized?(modules: ModuleMetadata[]): void
  onRegistryError?(error: Error, moduleId?: string): void
}

ModuleDiscoveryService

Service for discovering modules from various sources.

Discovery Strategies

1. Package Scanning - Scans for @dbs-portal/module-* packages
2. Config Detection - Finds module.config.ts files
3. Runtime Registration - Allows manual registration

Options

interface DiscoveryOptions {
  packageScanPaths?: string[]
  configScanPaths?: string[]
  packageNamePattern?: string
  configFilePattern?: string
  enablePackageScanning?: boolean
  enableConfigDetection?: boolean
  enableRuntimeRegistration?: boolean
  validateModules?: boolean
  ignorePatterns?: string[]
}

Module Metadata Schema

Complete module configuration schema:

interface ModuleMetadata {
  // Core identification
  id: string
  name: string
  version: string
  description: string

  // Categorization
  category: ModuleCategory
  tags: string[]

  // Visual configuration
  icon: string
  color?: string

  // Security
  permissions: string[]
  roles?: string[]

  // Routing
  routes: ModuleRoute[]
  
  // Navigation
  navigation: NavigationItem[]

  // Dependencies
  dependencies: string[]

  // Status and metadata
  status: ModuleStatus
  priority: number
  author: string
  license: string

  // Optional features
  features?: Record<string, boolean>
  config?: Record<string, any>
}

Advanced Usage

Custom Discovery

import { ModuleDiscoveryService } from '@dbs-portal/core-module-registry'

const discovery = new ModuleDiscoveryService({
  packageScanPaths: ['custom/modules/*'],
  configFilePattern: 'my-module.config.ts',
  validateModules: true
})

const modules = await discovery.discoverModules()

Permission Filtering

import { filterModulesByPermissions } from '@dbs-portal/core-module-registry'

const userPermissions = ['FileManagement.View', 'Chat.View']
const accessibleModules = filterModulesByPermissions(modules, userPermissions)

Caching

import { ModuleCache } from '@dbs-portal/core-module-registry'

const cache = new ModuleCache(10 * 60 * 1000) // 10 minutes TTL
cache.set('my-key', { data: 'value' })
const value = cache.get('my-key')

Performance Monitoring

import { measurePerformance } from '@dbs-portal/core-module-registry'

const { result, duration } = await measurePerformance(
  () => registry.discoverModules(),
  'Module Discovery'
)

Integration with DBS Portal

Router Integration

// src/routes/dynamic.routes.ts
import { ModuleRegistry } from '@dbs-portal/core-module-registry'

export const createDynamicRoutes = async () => {
  const registry = ModuleRegistry.getInstance()
  const modules = registry.getActiveModules()
  
  return modules.flatMap(module => 
    module.routes.map(route => ({
      path: route.path,
      component: lazy(() => import(route.component))
    }))
  )
}

Navigation Integration

// src/components/navigation/DynamicNavigation.tsx
import { ModuleRegistry, groupModulesByCategory } from '@dbs-portal/core-module-registry'

export const DynamicNavigation = () => {
  const registry = ModuleRegistry.getInstance()
  const modules = registry.getActiveModules()
  const groupedModules = groupModulesByCategory(modules)
  
  return (
    <Menu>
      {Object.entries(groupedModules).map(([category, categoryModules]) => (
        <SubMenu key={category} title={category}>
          {categoryModules.flatMap(module => 
            module.navigation.map(nav => (
              <Menu.Item key={nav.key} icon={nav.icon}>
                {nav.label}
              </Menu.Item>
            ))
          )}
        </SubMenu>
      ))}
    </Menu>
  )
}

Development

# Install dependencies
yarn install

# Build the package
yarn build

# Run tests
yarn test

# Type checking
yarn type-check

# Linting
yarn lint

License

MIT © DBS Portal Team