@hkdigital/lib-core 0.4.19 → 0.4.21

package/dist/services/README.md

@@ -11,21 +11,32 @@ The services module provides two main components:
 
 All services follow a standardized state machine with proper error handling, logging, and health monitoring.
 
-## Service States
-
-Services transition through these states during their lifecycle:
-
-- `created` - Service instantiated but not configured
-- `configuring` - Currently running configuration
-- `configured` - Ready to start
-- `starting` - Currently starting up
-- `running` - Operational and healthy
-- `stopping` - Currently shutting down
-- `stopped` - Cleanly stopped
-- `destroying` - Being destroyed and cleaned up
-- `destroyed` - Completely destroyed
-- `error` - Failed and non-operational
-- `recovering` - Attempting recovery from error
+## Service states
+
+Services transition through these states during their lifecycle. Use these constants from `$lib/services/service-base/constants.js`:
+
+- `STATE_CREATED` - Service instantiated but not configured
+- `STATE_CONFIGURING` - Currently running configuration
+- `STATE_CONFIGURED` - Ready to start
+- `STATE_STARTING` - Currently starting up
+- `STATE_RUNNING` - Operational and healthy
+- `STATE_STOPPING` - Currently shutting down
+- `STATE_STOPPED` - Cleanly stopped
+- `STATE_DESTROYING` - Being destroyed and cleaned up
+- `STATE_DESTROYED` - Completely destroyed
+- `STATE_ERROR` - Failed and non-operational
+- `STATE_RECOVERING` - Attempting recovery from error
+
+```javascript
+import {
+  STATE_RUNNING,
+  STATE_ERROR
+} from '$lib/services/service-base/constants.js';
+
+if (service.state === STATE_RUNNING) {
+  // Service is operational
+}
+```
 
 ## ServiceBase
 
@@ -46,7 +57,6 @@ import { ServiceBase } from '$lib/services/index.js';
 class DatabaseService extends ServiceBase {
   // eslint-disable-next-line no-unused-vars
   async _configure(newConfig, oldConfig = null) {
-
     if (!oldConfig) {
       // Initial configuration
 
@@ -106,7 +116,7 @@ db.on('healthChanged', ({ healthy }) => {
 // Reconfigure at runtime
 await db.configure({
   connectionString: 'postgres://localhost/myapp',
-  maxConnections: 50  // Hot-reloaded without restart
+  maxConnections: 50 // Hot-reloaded without restart
 });
 ```
 
@@ -119,11 +129,22 @@ await db.configure({
 - `_recover()` - Custom recovery logic (optional)
 - `_healthCheck()` - Return health status (optional)
 
-### Events
+### Service events
+
+ServiceBase emits these events (constants from `$lib/services/service-base/constants.js`):
 
-- `stateChanged` - Service state transitions
-- `healthChanged` - Health status changes
-- `error` - Service errors
+- `EVENT_STATE_CHANGED` - Service state transitions
+- `EVENT_TARGET_STATE_CHANGED` - Target state changes
+- `EVENT_HEALTH_CHANGED` - Health status changes
+- `EVENT_ERROR` - Service errors
+
+```javascript
+import { EVENT_STATE_CHANGED } from '$lib/services/service-base/constants.js';
+
+service.on(EVENT_STATE_CHANGED, ({ state, previousState }) => {
+  console.log(`Service transitioned from ${previousState} to ${state}`);
+});
+```
 
 ## ServiceManager
 
@@ -143,6 +164,7 @@ Manages multiple services with dependency resolution and coordinated lifecycle o
 
 ```javascript
 import { ServiceManager } from '$hklib-core/services/index.js';
+
 import DatabaseService from './services/DatabaseService.js';
 import AuthService from './services/AuthService.js';
 
@@ -156,11 +178,16 @@ manager.register('database', DatabaseService, {
   connectionString: 'postgres://localhost/myapp'
 });
 
-manager.register('auth', AuthService, {
-  secret: process.env.JWT_SECRET
-}, {
-  dependencies: ['database'] // auth depends on database
-});
+manager.register(
+  'auth',
+  AuthService,
+  {
+    secret: process.env.JWT_SECRET
+  },
+  {
+    dependencies: ['database'] // auth depends on database
+  }
+);
 
 // Start all services in dependency order
 await manager.startAll();
@@ -175,19 +202,27 @@ await manager.stopAll();
 ### Service Registration
 
 ```javascript
-manager.register(name, ServiceClass, config, options);
+manager.register(name, ServiceClass, serviceConfigOrLabel, options);
 ```
 
 - `name` - Unique service identifier
 - `ServiceClass` - Class extending ServiceBase
-- `config` - Service-specific configuration
+- `serviceConfigOrLabel` - Service configuration object (`Object<string, *>`) or config label string
 - `options.dependencies` - Array of service names this service depends on
+- `options.startupPriority` - Higher priority services start first (default: 0)
 
 ### Health Monitoring
 
 ```javascript
+import {
+  SERVICE_HEALTH_CHANGED,
+  SERVICE_ERROR,
+  SERVICE_STATE_CHANGED,
+  SERVICE_LOG
+} from '$lib/services/service-manager/constants.js';
+
 // Listen for health changes
-manager.on('service:healthChanged', ({ service, healthy }) => {
+manager.on(SERVICE_HEALTH_CHANGED, ({ service, healthy }) => {
   if (!healthy) {
     console.error(`Service ${service} became unhealthy`);
   }
@@ -202,11 +237,20 @@ const systemHealth = await manager.checkHealth();
 
 ### Error Handling and Recovery
 
+### ServiceManager events
+
+ServiceManager emits these events (constants from `$lib/services/service-manager/constants.js`):
+
+- `SERVICE_STATE_CHANGED` - Service state changes
+- `SERVICE_HEALTH_CHANGED` - Service health changes
+- `SERVICE_ERROR` - Service errors
+- `SERVICE_LOG` - Service log messages
+
 ```javascript
 // Listen for service errors
-manager.on('service:error', async ({ service, error }) => {
+manager.on(SERVICE_ERROR, async ({ service, error }) => {
   console.log(`Service ${service} failed:`, error.message);
-  
+
   // Attempt automatic recovery
   await manager.recoverService(service);
 });
@@ -215,9 +259,9 @@ manager.on('service:error', async ({ service, error }) => {
 await manager.recoverService('database');
 ```
 
-## Configuration Plugins
+## Plugins
 
-ServiceManager supports plugins that can resolve service configuration dynamically. This is particularly useful for environment-based configuration.
+ServiceManager supports plugins e.g. to resolve service configurations dynamically.
 
 ### ConfigPlugin
 
@@ -227,17 +271,29 @@ The most common plugin for resolving service configuration from a pre-parsed con
 
 ```javascript
 import { ServiceManager } from '$lib/services/index.js';
-import ConfigPlugin from '$lib/services/service-manager-plugins/ConfigPlugin.js';
+
+import ConfigPlugin from '$lib/services/manager-plugins/ConfigPlugin.js';
+
 import { getPrivateEnv } from '$lib/util/sveltekit/env-private.js';
 
 // Load and auto-group environment variables
 const envConfig = getPrivateEnv();
-// Example result:
+//
+// Example:
+//
+// DATABASE_HOST=localhost
+// DATABASE_PORT=5432
+// DATABASE_NAME=myapp
+// REDIS_HOST=cache-server
+// REDIS_PORT=6379
+// JWT_SECRET=mysecret
+// =>
 // {
 //   database: { host: 'localhost', port: 5432, name: 'myapp' },
 //   redis: { host: 'cache-server', port: 6379 },
 //   jwtSecret: 'mysecret'
 // }
+//
 
 // Create plugin with grouped config
 const configPlugin = new ConfigPlugin(envConfig);
@@ -247,46 +303,23 @@ const manager = new ServiceManager();
 manager.attachPlugin(configPlugin);
 
 // Register services with config labels (not config objects)
-manager.register('database', DatabaseService, 'database');  // Uses envConfig.database
-manager.register('cache', RedisService, 'redis');           // Uses envConfig.redis
+manager.register('database', DatabaseService, 'database'); // Uses envConfig.database
+manager.register('cache', RedisService, 'redis'); // Uses envConfig.redis
 
 await manager.startAll();
 ```
 
-#### Environment Variable Grouping
-
-The environment utilities automatically group related variables by prefix:
-
-```bash
-# Environment variables:
-DATABASE_HOST=localhost
-DATABASE_PORT=5432
-DATABASE_NAME=myapp
-REDIS_HOST=cache-server
-REDIS_PORT=6379
-JWT_SECRET=mysecret
-SINGLE_FLAG=true
-```
-
-```javascript
-const envConfig = getPrivateEnv();
-// Auto-groups into:
-// {
-//   database: { host: 'localhost', port: 5432, name: 'myapp' },
-//   redis: { host: 'cache-server', port: 6379 },
-//   jwtSecret: 'mysecret',
-//   singleFlag: true
-// }
-```
+#### Configuration
 
-#### Advanced Configuration Sources
+The plugin constructor accepts an object with configuration data, which can come from any source. E.g. the environment or a configuration file.
 
 ```javascript
 // Combine multiple config sources
 const config = {
-  ...getPrivateEnv(),              // Environment variables
-  ...await loadConfigFile(),       // Config file
-  database: {                      // Override specific settings
+  ...getPrivateEnv(), // Environment variables
+  ...(await loadConfigFile()), // Config file
+  database: {
+    // Override specific settings
     ...envConfig.database,
     connectionTimeout: 5000
   }
@@ -295,41 +328,17 @@ const config = {
 const plugin = new ConfigPlugin(config);
 ```
 
-#### Plugin Benefits
-
-1. **Simple Service Registration** - Use string labels instead of complex config objects
-2. **Environment Integration** - Seamless SvelteKit environment variable integration
-3. **Dynamic Configuration** - Update config object for live updates
-4. **Clear Separation** - Configuration logic separate from service logic
-5. **Extensible** - Easy to add custom configuration sources
-
-#### Available Environment Utilities
+### Methods
 
 ```javascript
-// Server-side only (private + public env vars)
-import { getAllEnv } from '$lib/util/sveltekit/env-all.js';
-const config = getAllEnv();
+// Replace all configurations and clean up unused ones
+await configPlugin.replaceAllConfigs(newConfig);
 
-// Server-side only (private env vars only)
-import { getPrivateEnv } from '$lib/util/sveltekit/env-private.js';
-const config = getPrivateEnv();
+// Replace configuration for a specific label
+await configPlugin.replaceConfig('database', newDatabaseConfig);
 
-// Client + server safe (public env vars only)  
-import { getPublicEnv } from '$lib/util/sveltekit/env-public.js';
-const config = getPublicEnv();
-```
-
-### Plugin Methods
-
-```javascript
-// Update configuration at runtime
-configPlugin.updateConfigObject(newConfig);
-
-// Merge additional configuration
-configPlugin.mergeConfig({ additionalSettings: true });
-
-// Get current configuration
-const currentConfig = configPlugin.getConfigObject();
+// Clean up configurations not used by any service
+await configPlugin.cleanupConfigs();
 ```
 
 ### Live Configuration Updates
@@ -337,8 +346,8 @@ const currentConfig = configPlugin.getConfigObject();
 The ConfigPlugin supports pushing configuration updates to running services:
 
 ```javascript
-// Update config for a specific label and notify all affected services
-const updatedServices = await configPlugin.updateConfigLabel('database', {
+// Replace config for a specific label and notify all affected services
+const updatedServices = await configPlugin.replaceConfig('database', {
   host: 'new-host.example.com',
   port: 5433,
   maxConnections: 50
@@ -348,15 +357,6 @@ const updatedServices = await configPlugin.updateConfigLabel('database', {
 console.log(`Updated ${updatedServices.length} services`);
 ```
 
-#### How Live Updates Work
-
-1. **Updates the plugin's config object** for the specified label
-2. **Finds all running services** that use that config label  
-3. **Calls `_configure(newConfig, oldConfig)`** on each service instance
-4. **Updates the resolved config** stored in the ServiceManager
-5. **Returns the list** of successfully updated service names
-6. **Handles errors gracefully** with detailed logging
-
 #### Service Requirements for Live Updates
 
 For services to support live configuration updates, they must:
@@ -381,7 +381,7 @@ class DatabaseService extends ServiceBase {
       // Connection changed - need to reconnect
       await this.connection?.close();
       this.connectionString = newConfig.connectionString;
-      
+
       if (this.state === 'running') {
         this.connection = await createConnection(this.connectionString);
       }
@@ -396,12 +396,6 @@ class DatabaseService extends ServiceBase {
 }
 ```
 
-This enables powerful scenarios like:
-- **Runtime environment updates** without service restarts
-- **A/B testing configuration changes** with instant rollback
-- **Dynamic scaling** based on load conditions
-- **Configuration management systems** that push updates to running applications
-
 ## Best Practices
 
 1. **Always extend ServiceBase** for consistent lifecycle management
@@ -411,15 +405,3 @@ This enables powerful scenarios like:
 5. **Declare dependencies explicitly** when registering with ServiceManager
 6. **Handle errors gracefully** and implement recovery where appropriate
 7. **Use descriptive service names** for better logging and debugging
-
-## Testing
-
-Services include comprehensive test suites demonstrating:
-
-- Lifecycle state transitions
-- Error handling and recovery
-- Dependency resolution
-- Health monitoring
-- Event emission
-
-Run tests with your project's test command to ensure service reliability.

package/dist/services/{service-manager-plugins → manager-plugins}/ConfigPlugin.d.ts

@@ -1,3 +1,4 @@
+/** @typedef {import('../service-manager/typedef.js').ServiceEntry} ServiceEntry */
 /**
  * Plugin that resolves service configuration from a configuration object
  */
@@ -5,9 +6,9 @@ export default class ConfigPlugin {
     /**
      * Create a new object configuration plugin
      *
-     * @param {Object<string, *>} configObject - Pre-parsed configuration object
+     * @param {Object<string, *>} allConfigs - Pre-parsed configuration object
      */
-    constructor(configObject: {
+    constructor(allConfigs: {
         [x: string]: any;
     });
     /** @type {string} */
@@ -15,54 +16,42 @@ export default class ConfigPlugin {
     /** @type {import('../service-manager/ServiceManager.js').ServiceManager|null} */
     manager: import("../service-manager/ServiceManager.js").ServiceManager | null;
     /** @type {Object<string, *>} */
-    configObject: {
+    allConfigs: {
         [x: string]: any;
     };
     /**
      * Resolve service configuration from the configuration object
      *
-     * @param {string} serviceName - Name of the service being configured
-     * @param {import('../service-manager/typedef.js').ServiceEntry} serviceEntry
-     *   Service registration entry
-     * @param {*} currentConfig - Current config (could be object from previous plugins)
+     * @param {string} serviceName
+     * @param {ServiceEntry} serviceEntry - Service registration entry
+     * @param {*} currentConfig
+     *   Current config (could be object from previous plugins)
      *
      * @returns {Promise<Object|undefined>}
      *   Resolved config object, or undefined to use currentConfig as-is
      */
-    _getServiceConfig(serviceName: string, serviceEntry: import("../service-manager/typedef.js").ServiceEntry, currentConfig: any): Promise<any | undefined>;
+    resolveServiceConfig(serviceName: string, serviceEntry: ServiceEntry, currentConfig: any): Promise<any | undefined>;
     /**
-     * Update the configuration object
+     * Replace the entire configuration object and clean up unused configs
      *
      * @param {Object<string, *>} newConfigObject - New configuration object
      */
-    updateConfigObject(newConfigObject: {
+    replaceAllConfigs(newConfigObject: {
         [x: string]: any;
-    }): void;
+    }): Promise<void>;
     /**
-     * Merge additional configuration into the existing object
-     *
-     * @param {Object<string, *>} additionalConfig - Additional configuration
-     */
-    mergeConfig(additionalConfig: {
-        [x: string]: any;
-    }): void;
-    /**
-     * Get the current configuration object
-     *
-     * @returns {Object<string, *>} Current configuration object
-     */
-    getConfigObject(): {
-        [x: string]: any;
-    };
-    /**
-     * Update config for a specific label and push to affected services
+     * Replace a config for a specific label and push to affected services
      *
      * @param {string} configLabel - Config label to update
      * @param {*} newConfig - New configuration value
      *
      * @returns {Promise<string[]>} Array of service names that were updated
      */
-    updateConfigLabel(configLabel: string, newConfig: any): Promise<string[]>;
+    replaceConfig(configLabel: string, newConfig: any): Promise<string[]>;
+    /**
+     * Remove all unused configurations (configs not referenced by any service)
+     */
+    cleanupConfigs(): Promise<void>;
     /**
      * Attach plugin to ServiceManager
      *
@@ -76,3 +65,4 @@ export default class ConfigPlugin {
     detach(): void;
     #private;
 }
+export type ServiceEntry = import("../service-manager/typedef.js").ServiceEntry;

package/dist/services/{service-manager-plugins → manager-plugins}/ConfigPlugin.js

@@ -8,12 +8,12 @@
  * // Basic usage with config object
  * import ConfigPlugin from './ConfigPlugin.js';
  *
- * const configObject = {
+ * const allConfigs = {
  *   'database': { host: 'localhost', port: 5432 },
  *   'auth': { secret: 'my-secret', algorithm: 'HS256' }
  * };
  *
- * const objectPlugin = new ConfigPlugin(configObject);
+ * const objectPlugin = new ConfigPlugin(allConfigs);
  * manager.attachPlugin(objectPlugin);
  *
  * @example
@@ -41,20 +41,21 @@
 
 import { SERVICE_STATE_CHANGED } from '../service-manager/constants.js';
 
+/** @typedef {import('../service-manager/typedef.js').ServiceEntry} ServiceEntry */
+
 /**
  * Plugin that resolves service configuration from a configuration object
  */
 export default class ConfigPlugin {
-
   /** @type {Map<string, *>} */
   #pendingConfigUpdates;
 
   /**
    * Create a new object configuration plugin
    *
-   * @param {Object<string, *>} configObject - Pre-parsed configuration object
+   * @param {Object<string, *>} allConfigs - Pre-parsed configuration object
    */
-  constructor(configObject) {
+  constructor(allConfigs) {
     /** @type {string} */
     this.name = 'object-config';
 
@@ -62,7 +63,7 @@ export default class ConfigPlugin {
     this.manager = null;
 
     /** @type {Object<string, *>} */
-    this.configObject = configObject || {};
+    this.allConfigs = allConfigs || {};
 
     this.#pendingConfigUpdates = new Map();
   }
@@ -70,25 +71,32 @@ export default class ConfigPlugin {
   /**
    * Resolve service configuration from the configuration object
    *
-   * @param {string} serviceName - Name of the service being configured
-   * @param {import('../service-manager/typedef.js').ServiceEntry} serviceEntry
-   *   Service registration entry
-   * @param {*} currentConfig - Current config (could be object from previous plugins)
+   * @param {string} serviceName
+   * @param {ServiceEntry} serviceEntry - Service registration entry
+   * @param {*} currentConfig
+   *   Current config (could be object from previous plugins)
    *
    * @returns {Promise<Object|undefined>}
    *   Resolved config object, or undefined to use currentConfig as-is
    */
   // eslint-disable-next-line no-unused-vars
-  async _getServiceConfig(serviceName, serviceEntry, currentConfig) {
-    // Only handle string config labels from original registration
-    if (typeof serviceEntry.config !== 'string') {
+  async resolveServiceConfig(serviceName, serviceEntry, currentConfig) {
+    // console.log(`ConfigPlugin.resolveServiceConfig called for '${serviceName}'`);
+    // console.log('ServiceEntry:', serviceEntry);
+    // console.log('AllConfigs:', this.allConfigs);
+    
+    const configLabel = serviceEntry.serviceConfigOrLabel;
+    // console.log('Config label:', configLabel, 'Type:', typeof configLabel);
+
+    if (typeof configLabel !== 'string') {
+      // console.log('Config label is not string, returning undefined');
+      // Expected config label
       return undefined;
     }
 
-    const configLabel = serviceEntry.config;
-
     // Simple object lookup
-    const config = this.configObject[configLabel];
+    const config = this.allConfigs[configLabel];
+    // console.log(`Looking up config for label '${configLabel}':`, config);
 
     if (config !== undefined) {
       this.manager?.logger?.debug(
@@ -98,65 +106,69 @@ export default class ConfigPlugin {
             typeof config === 'object' ? Object.keys(config) : 'primitive'
         }
       );
+      // console.log(`Resolved config for '${serviceName}':`, config);
+    } else {
+      // console.log(`No config found for label '${configLabel}'`);
     }
 
     return config;
   }
 
   /**
-   * Update the configuration object
+   * Replace the entire configuration object and clean up unused configs
    *
    * @param {Object<string, *>} newConfigObject - New configuration object
    */
-  updateConfigObject(newConfigObject) {
-    this.configObject = newConfigObject || {};
-    this.manager?.logger?.debug('Updated configuration object');
-  }
+  async replaceAllConfigs(newConfigObject) {
+    await this.cleanupConfigs();
 
-  /**
-   * Merge additional configuration into the existing object
-   *
-   * @param {Object<string, *>} additionalConfig - Additional configuration
-   */
-  mergeConfig(additionalConfig) {
-    this.configObject = { ...this.configObject, ...additionalConfig };
-    this.manager?.logger?.debug('Merged additional configuration');
-  }
+    // Apply new configs to all services that have config labels
+    const updatedServices = [];
+    for (const [configLabel, newConfig] of Object.entries(
+      newConfigObject || {}
+    )) {
+      const services = await this.replaceConfig(configLabel, newConfig);
+      updatedServices.push(...services);
+    }
 
-  /**
-   * Get the current configuration object
-   *
-   * @returns {Object<string, *>} Current configuration object
-   */
-  getConfigObject() {
-    return { ...this.configObject };
+    this.manager?.logger?.debug(
+      `Replaced all configurations, updated ${updatedServices.length} services`
+    );
   }
 
   /**
-   * Update config for a specific label and push to affected services
+   * Replace a config for a specific label and push to affected services
    *
    * @param {string} configLabel - Config label to update
    * @param {*} newConfig - New configuration value
    *
    * @returns {Promise<string[]>} Array of service names that were updated
    */
-  async updateConfigLabel(configLabel, newConfig) {
+  async replaceConfig(configLabel, newConfig) {
     // Update the config object
-    this.configObject[configLabel] = newConfig;
+    this.allConfigs[configLabel] = newConfig;
 
     // Store as pending update
     this.#pendingConfigUpdates.set(configLabel, newConfig);
 
     const updatedServices = [];
 
-    // Find all services using this config label
-    for (const [serviceName, serviceEntry] of this.manager.services) {
-      if (serviceEntry.config === configLabel && serviceEntry.instance) {
+    // Find all services using this config label using helper function
+    const servicesByLabel = this.#servicesByConfigLabel();
+    const serviceNames = servicesByLabel.get(configLabel) || [];
+
+    for (const serviceName of serviceNames) {
+      const serviceEntry = this.manager.services.get(serviceName);
+      if (serviceEntry && serviceEntry.instance) {
         try {
           // Try to apply config - ServiceBase.configure() will handle state validation
-          await this.#applyConfigToService(serviceName, serviceEntry, newConfig);
+          await this.#applyConfigToService(
+            serviceName,
+            serviceEntry,
+            newConfig
+          );
           updatedServices.push(serviceName);
-          
+
           // Remove from pending since it was applied
           this.#pendingConfigUpdates.delete(configLabel);
         } catch (error) {
@@ -175,6 +187,60 @@ export default class ConfigPlugin {
     return updatedServices;
   }
 
+  /**
+   * Get services organized by their config labels
+   *
+   * @returns {Map<string, string[]>}
+   *   Map where keys are config labels and values are arrays of service names
+   */
+  #servicesByConfigLabel() {
+    const servicesByLabel = new Map();
+
+    for (const [serviceName, serviceEntry] of this.manager.services) {
+      const configLabel = serviceEntry.serviceConfigOrLabel;
+
+      if (typeof configLabel === 'string') {
+        if (!servicesByLabel.has(configLabel)) {
+          servicesByLabel.set(configLabel, []);
+        }
+
+        servicesByLabel.get(configLabel).push(serviceName);
+      }
+    }
+
+    return servicesByLabel;
+  }
+
+  /**
+   * Remove all unused configurations (configs not referenced by any service)
+   */
+  async cleanupConfigs() {
+    const usedConfigLabels = new Set();
+
+    // Collect all config labels used by registered services
+    for (const [, serviceEntry] of this.manager.services) {
+      const configLabel = serviceEntry.serviceConfigOrLabel;
+
+      if (typeof configLabel === 'string') {
+        usedConfigLabels.add(configLabel);
+      }
+    }
+
+    // Remove configs that aren't used by any service
+    const configKeys = Object.keys(this.allConfigs);
+    let removedCount = 0;
+
+    for (const key of configKeys) {
+      if (!usedConfigLabels.has(key)) {
+        delete this.allConfigs[key];
+        removedCount++;
+      }
+    }
+
+    this.manager?.logger?.debug(
+      `Cleaned up ${removedCount} unused configurations`
+    );
+  }
 
   /**
    * Apply configuration to a specific service
@@ -187,9 +253,7 @@ export default class ConfigPlugin {
   async #applyConfigToService(serviceName, serviceEntry, newConfig) {
     await serviceEntry.instance.configure(newConfig);
 
-    this.manager.logger.info(
-      `Updated config for service '${serviceName}'`
-    );
+    this.manager.logger.info(`Updated config for service '${serviceName}'`);
   }
 
   /**
@@ -201,18 +265,24 @@ export default class ConfigPlugin {
    */
   async #processPendingUpdates(serviceName, serviceInstance) {
     const serviceEntry = this.manager.services.get(serviceName);
-    if (!serviceEntry || typeof serviceEntry.config !== 'string') {
+
+    const configLabel = serviceEntry?.serviceConfigOrLabel;
+
+    if (typeof configLabel !== 'string') {
       return;
     }
 
-    const configLabel = serviceEntry.config;
     if (this.#pendingConfigUpdates.has(configLabel)) {
       const pendingConfig = this.#pendingConfigUpdates.get(configLabel);
-      
+
       try {
-        await this.#applyConfigToService(serviceName, serviceEntry, pendingConfig);
+        await this.#applyConfigToService(
+          serviceName,
+          serviceEntry,
+          pendingConfig
+        );
         this.#pendingConfigUpdates.delete(configLabel);
-        
+
         this.manager.logger.info(
           `Applied pending config update for service '${serviceName}' (label: ${configLabel})`
         );
@@ -239,16 +309,19 @@ export default class ConfigPlugin {
 
     this.manager = manager;
 
-    const configKeys = Object.keys(this.configObject).length;
+    const configKeys = Object.keys(this.allConfigs).length;
 
     this.manager.logger.info(
       `ConfigPlugin attached with ${configKeys} config keys`
     );
 
     // Listen for service state changes to process pending updates
-    this.manager.on(SERVICE_STATE_CHANGED, async ({ service, state, instance }) => {
-      await this.#processPendingUpdates(service, instance);
-    });
+    this.manager.on(
+      SERVICE_STATE_CHANGED,
+      async ({ service, state, instance }) => {
+        await this.#processPendingUpdates(service, instance);
+      }
+    );
   }
 
   /**
@@ -258,7 +331,7 @@ export default class ConfigPlugin {
     if (this.manager) {
       // Clear pending updates
       this.#pendingConfigUpdates.clear();
-      
+
       this.manager.logger.info('ConfigPlugin detached');
       this.manager = null;
     }

package/dist/services/service-base/constants.js

@@ -124,4 +124,3 @@ export const EVENT_HEALTH_CHANGED = 'healthChanged';
  * Event emitted when service encounters an error
  */
 export const EVENT_ERROR = 'error';
-

package/dist/services/service-base/typedef.js

@@ -1,17 +1,17 @@
 /**
  * @fileoverview Type definitions for ServiceBase class.
- * 
+ *
  * This file contains all TypeScript/JSDoc type definitions used by
  * the ServiceBase class and service implementations.
- * 
+ *
  * @example
  * // In your service implementation
  * import { ServiceBase } from './ServiceBase.js';
- * 
+ *
  * class MyService extends ServiceBase {
  *   async _configure(newConfig, oldConfig) {
  *   }
- *   
+ *
  *   async _healthCheck() {
  *     // Return type is HealthStatus
  *     return { latency: 10 };

package/dist/services/service-manager/ServiceManager.d.ts

@@ -3,6 +3,7 @@
  * @typedef {import('./typedef.js').ServiceRegistrationOptions} ServiceRegistrationOptions
  * @typedef {import('./typedef.js').ServiceManagerConfig} ServiceManagerConfig
  * @typedef {import('./typedef.js').ServiceEntry} ServiceEntry
+ * @typedef {import('./typedef.js').ServiceConfigOrLabel} ServiceConfigOrLabel
  * @typedef {import('./typedef.js').HealthCheckResult} HealthCheckResult
  *
  * @typedef {import('../service-base/typedef.js').StopOptions} StopOptions
@@ -46,12 +47,13 @@ export class ServiceManager extends EventEmitter {
      *
      * @param {string} name - Unique service identifier
      * @param {ServiceConstructor} ServiceClass - Service class constructor
-     * @param {*} [config={}] - Service configuration
+     * @param {ServiceConfigOrLabel} [serviceConfigOrLabel={}]
+     *   Service configuration object or config label string
      * @param {ServiceRegistrationOptions} [options={}] - Registration options
      *
      * @throws {Error} If service name is already registered
      */
-    register(name: string, ServiceClass: ServiceConstructor, config?: any, options?: ServiceRegistrationOptions): void;
+    register(name: string, ServiceClass: ServiceConstructor, serviceConfigOrLabel?: ServiceConfigOrLabel, options?: ServiceRegistrationOptions): void;
     /**
      * Get or create a service instance
      *
@@ -156,6 +158,7 @@ export type ServiceConstructor = import("./typedef.js").ServiceConstructor;
 export type ServiceRegistrationOptions = import("./typedef.js").ServiceRegistrationOptions;
 export type ServiceManagerConfig = import("./typedef.js").ServiceManagerConfig;
 export type ServiceEntry = import("./typedef.js").ServiceEntry;
+export type ServiceConfigOrLabel = import("./typedef.js").ServiceConfigOrLabel;
 export type HealthCheckResult = import("./typedef.js").HealthCheckResult;
 export type StopOptions = import("../service-base/typedef.js").StopOptions;
 import { EventEmitter } from '../../generic/events.js';

package/dist/services/service-manager/ServiceManager.js

@@ -78,6 +78,7 @@ import {
  * @typedef {import('./typedef.js').ServiceRegistrationOptions} ServiceRegistrationOptions
  * @typedef {import('./typedef.js').ServiceManagerConfig} ServiceManagerConfig
  * @typedef {import('./typedef.js').ServiceEntry} ServiceEntry
+ * @typedef {import('./typedef.js').ServiceConfigOrLabel} ServiceConfigOrLabel
  * @typedef {import('./typedef.js').HealthCheckResult} HealthCheckResult
  *
  * @typedef {import('../service-base/typedef.js').StopOptions} StopOptions
@@ -158,12 +159,13 @@ export class ServiceManager extends EventEmitter {
    *
    * @param {string} name - Unique service identifier
    * @param {ServiceConstructor} ServiceClass - Service class constructor
-   * @param {*} [config={}] - Service configuration
+   * @param {ServiceConfigOrLabel} [serviceConfigOrLabel={}]
+   *   Service configuration object or config label string
    * @param {ServiceRegistrationOptions} [options={}] - Registration options
    *
    * @throws {Error} If service name is already registered
    */
-  register(name, ServiceClass, config = {}, options = {}) {
+  register(name, ServiceClass, serviceConfigOrLabel = {}, options = {}) {
     if (this.services.has(name)) {
       throw new Error(`Service '${name}' already registered`);
     }
@@ -172,11 +174,11 @@ export class ServiceManager extends EventEmitter {
     const entry = {
       ServiceClass,
       instance: null,
-      config,
+      serviceConfigOrLabel: serviceConfigOrLabel,
       dependencies: options.dependencies || [],
       dependents: new Set(),
       tags: options.tags || [],
-      priority: options.priority || 0
+      startupPriority: options.startupPriority || 0
     };
 
     // Track dependents
@@ -245,7 +247,7 @@ export class ServiceManager extends EventEmitter {
     if (!instance) return false;
 
     const entry = this.services.get(name);
-    const config = await this.#resolveConfig(name, entry);
+    const config = await this.#resolveServiceConfig(name, entry);
 
     return await instance.configure(config);
   }
@@ -559,25 +561,29 @@ export class ServiceManager extends EventEmitter {
    *
    * @returns {Promise<*>} Resolved configuration object
    */
-  async #resolveConfig(serviceName, serviceEntry) {
-    let config = serviceEntry.config;
-
-    // Let plugins resolve the config
-    for (const plugin of this.#plugins.values()) {
-      if (plugin._getServiceConfig) {
-        const resolved = await plugin._getServiceConfig(
-          serviceName,
-          serviceEntry,
-          config
-        );
-        if (resolved !== undefined) {
-          config = resolved;
-          break; // First plugin that resolves wins
+  async #resolveServiceConfig(serviceName, serviceEntry) {
+    let serviceConfigOrLabel = serviceEntry.serviceConfigOrLabel;
+
+    if (typeof serviceConfigOrLabel === 'string') {
+      const configLabel = serviceConfigOrLabel;
+
+      // Let plugins resolve the config
+      for (const plugin of this.#plugins.values()) {
+        if (plugin.resolveServiceConfig) {
+          const config = await plugin.resolveServiceConfig(
+            serviceName,
+            serviceEntry,
+            configLabel
+          );
+          if (config !== undefined) {
+            return config; // First plugin that resolves wins
+          }
         }
       }
+    } else {
+      const config = serviceConfigOrLabel;
+      return config;
     }
-
-    return config || {};
   }
 
   /**

package/dist/services/service-manager/constants.js

@@ -1,4 +1,3 @@
-
 // Log event names
 export const SERVICE_STATE_CHANGED = 'service:state-changed';
 export const SERVICE_HEALTH_CHANGED = 'service:health-changed';

package/dist/services/service-manager/typedef.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Service configuration - either a config object or a config label string
+ */
+export type ServiceConfigOrLabel = {
+    [x: string]: any;
+} | string;
 /**
  * Options for registering a service
  */
@@ -11,9 +17,9 @@ export type ServiceRegistrationOptions = {
      */
     tags?: string[];
     /**
-     * - Startup priority (higher starts first)
+     * - Higher starts first
      */
-    priority?: number;
+    startupPriority?: number;
 };
 /**
  * Configuration for ServiceManager
@@ -92,7 +98,7 @@ export type ServiceManagerPlugin = {
     /**
      * - Optional config resolution method
      */
-    _getServiceConfig?: (arg0: string, arg1: ServiceEntry, arg2: any) => Promise<any | undefined>;
+    resolveServiceConfig?: (arg0: string, arg1: ServiceEntry, arg2: any) => Promise<any | undefined>;
 };
 /**
  * Internal service registry entry
@@ -106,24 +112,15 @@ export type ServiceEntry = {
      * - Service instance (lazy-created)
      */
     instance: import("../service-base/typedef.js").ServiceInstance | null;
-    /**
-     * - Service configuration
-     */
-    config: any;
-    /**
-     * - Service dependencies
-     */
+    serviceConfigOrLabel: ServiceConfigOrLabel;
     dependencies: string[];
     /**
-     * - Services that depend on this one
+     * - Services that depend on this service
      */
     dependents: Set<string>;
-    /**
-     * - Service tags
-     */
     tags: string[];
     /**
      * - Startup priority
      */
-    priority: number;
+    startupPriority: number;
 };

package/dist/services/service-manager/typedef.js

@@ -1,28 +1,28 @@
 /**
  * @fileoverview Type definitions for ServiceManager class.
- * 
+ *
  * This file contains all TypeScript/JSDoc type definitions used by
  * the ServiceManager class and service registration.
- * 
+ *
  * @example
  * // When using ServiceManager
  * import { ServiceManager } from './ServiceManager.js';
- * 
+ *
  * // @ typedef {import('./typedef-service-manager.js').ServiceManagerConfig} ServiceManagerConfig
  * // @ typedef {import('./typedef-service-manager.js').ServiceRegistrationOptions} ServiceRegistrationOptions
- * 
+ *
  * const config = {
  *   environment: 'development',
  *   stopTimeout: 5000
  * };
- * 
+ *
  * const manager = new ServiceManager(config);
- * 
+ *
  * const options = {
  *   dependencies: ['database'],
  *   tags: ['critical']
  * };
- * 
+ *
  * manager.register('auth', AuthService, {}, options);
  */
 
@@ -30,13 +30,19 @@
 // PUBLIC TYPES
 // ============================================================================
 
+/**
+ * Service configuration - either a config object or a config label string
+ *
+ * @typedef {Object<string, *>|string} ServiceConfigOrLabel
+ */
+
 /**
  * Options for registering a service
  *
  * @typedef {Object} ServiceRegistrationOptions
  * @property {string[]} [dependencies=[]] - Services this service depends on
  * @property {string[]} [tags=[]] - Tags for grouping services
- * @property {number} [priority=0] - Startup priority (higher starts first)
+ * @property {number} [startupPriority=0] - Higher starts first
  */
 
 /**
@@ -78,7 +84,7 @@
  * @property {import('./ServiceManager.js').ServiceManager|null} manager - ServiceManager reference
  * @property {function(import('./ServiceManager.js').ServiceManager): void} attach - Attach to ServiceManager
  * @property {function(): void} detach - Detach from ServiceManager
- * @property {function(string, ServiceEntry, *): Promise<*|undefined>} [_getServiceConfig] - Optional config resolution method
+ * @property {function(string, ServiceEntry, *): Promise<*|undefined>} [resolveServiceConfig] - Optional config resolution method
  */
 
 // ============================================================================
@@ -91,11 +97,11 @@
  * @typedef {Object} ServiceEntry
  * @property {ServiceConstructor} ServiceClass - Service class constructor
  * @property {import('../service-base/typedef.js').ServiceInstance|null} instance - Service instance (lazy-created)
- * @property {*} config - Service configuration
- * @property {string[]} dependencies - Service dependencies
- * @property {Set<string>} dependents - Services that depend on this one
- * @property {string[]} tags - Service tags
- * @property {number} priority - Startup priority
+ * @property {ServiceConfigOrLabel} serviceConfigOrLabel
+ * @property {string[]} dependencies
+ * @property {Set<string>} dependents - Services that depend on this service
+ * @property {string[]} tags
+ * @property {number} startupPriority - Startup priority
  */
 
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.19",
+	"version": "0.4.21",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"