@objectstack/core 1.0.4 → 1.0.6

package/dist/plugin-loader.d.ts

@@ -1,164 +0,0 @@
-import { Plugin, PluginContext } from './types.js';
-import type { Logger } from '@objectstack/spec/contracts';
-import { z } from 'zod';
-/**
- * Service Lifecycle Types
- * Defines how services are instantiated and managed
- */
-export declare enum ServiceLifecycle {
-    /** Single instance shared across all requests */
-    SINGLETON = "singleton",
-    /** New instance created for each request */
-    TRANSIENT = "transient",
-    /** New instance per scope (e.g., per HTTP request) */
-    SCOPED = "scoped"
-}
-/**
- * Service Factory
- * Function that creates a service instance
- */
-export type ServiceFactory<T = any> = (ctx: PluginContext) => T | Promise<T>;
-/**
- * Service Registration Options
- */
-export interface ServiceRegistration {
-    name: string;
-    factory: ServiceFactory;
-    lifecycle: ServiceLifecycle;
-    dependencies?: string[];
-}
-/**
- * Plugin Configuration Validator Interface
- * Uses Zod for runtime validation of plugin configurations
- * @deprecated Use the PluginConfigValidator class from security module instead
- */
-export interface IPluginConfigValidator {
-    schema: z.ZodSchema;
-    validate(config: any): any;
-}
-/**
- * Plugin Metadata with Enhanced Features
- */
-export interface PluginMetadata extends Plugin {
-    /** Semantic version (e.g., "1.0.0") */
-    version: string;
-    /** Configuration schema for validation */
-    configSchema?: z.ZodSchema;
-    /** Plugin signature for security verification */
-    signature?: string;
-    /** Plugin health check function */
-    healthCheck?(): Promise<PluginHealthStatus>;
-    /** Startup timeout in milliseconds (default: 30000) */
-    startupTimeout?: number;
-    /** Whether plugin supports hot reload */
-    hotReloadable?: boolean;
-}
-/**
- * Plugin Health Status
- */
-export interface PluginHealthStatus {
-    healthy: boolean;
-    message?: string;
-    details?: Record<string, any>;
-    lastCheck?: Date;
-}
-/**
- * Plugin Load Result
- */
-export interface PluginLoadResult {
-    success: boolean;
-    plugin?: PluginMetadata;
-    error?: Error;
-    loadTime?: number;
-}
-/**
- * Plugin Startup Result
- */
-export interface PluginStartupResult {
-    success: boolean;
-    pluginName: string;
-    startTime?: number;
-    error?: Error;
-    timedOut?: boolean;
-}
-/**
- * Version Compatibility Result
- */
-export interface VersionCompatibility {
-    compatible: boolean;
-    pluginVersion: string;
-    requiredVersion?: string;
-    message?: string;
-}
-/**
- * Enhanced Plugin Loader
- * Provides advanced plugin loading capabilities with validation, security, and lifecycle management
- */
-export declare class PluginLoader {
-    private logger;
-    private context?;
-    private configValidator;
-    private loadedPlugins;
-    private serviceFactories;
-    private serviceInstances;
-    private scopedServices;
-    private creating;
-    constructor(logger: Logger);
-    /**
-     * Set the plugin context for service factories
-     */
-    setContext(context: PluginContext): void;
-    /**
-     * Get a synchronous service instance if it exists (Sync Helper)
-     */
-    getServiceInstance<T>(name: string): T | undefined;
-    /**
-     * Load a plugin asynchronously with validation
-     */
-    loadPlugin(plugin: Plugin): Promise<PluginLoadResult>;
-    /**
-     * Register a service with factory function
-     */
-    registerServiceFactory(registration: ServiceRegistration): void;
-    /**
-     * Get or create a service instance based on lifecycle type
-     */
-    getService<T>(name: string, scopeId?: string): Promise<T>;
-    /**
-     * Register a static service instance (legacy support)
-     */
-    registerService(name: string, service: any): void;
-    /**
-     * Check if a service is registered (either as instance or factory)
-     */
-    hasService(name: string): boolean;
-    /**
-     * Detect circular dependencies in service factories
-     * Note: This only detects cycles in service dependencies, not plugin dependencies.
-     * Plugin dependency cycles are detected in the kernel's resolveDependencies method.
-     */
-    detectCircularDependencies(): string[];
-    /**
-     * Check plugin health
-     */
-    checkPluginHealth(pluginName: string): Promise<PluginHealthStatus>;
-    /**
-     * Clear scoped services for a scope
-     */
-    clearScope(scopeId: string): void;
-    /**
-     * Get all loaded plugins
-     */
-    getLoadedPlugins(): Map<string, PluginMetadata>;
-    private toPluginMetadata;
-    private validatePluginStructure;
-    private checkVersionCompatibility;
-    private isValidSemanticVersion;
-    private validatePluginConfig;
-    private verifyPluginSignature;
-    private getSingletonService;
-    private createTransientService;
-    private getScopedService;
-    private createServiceInstance;
-}
-//# sourceMappingURL=plugin-loader.d.ts.map

package/dist/plugin-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-loader.d.ts","sourceRoot":"","sources":["../src/plugin-loader.ts"],"names":[],"mappings":"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"}

package/dist/plugin-loader.js

@@ -1,319 +0,0 @@
-import { PluginConfigValidator } from './security/plugin-config-validator.js';
-/**
- * Service Lifecycle Types
- * Defines how services are instantiated and managed
- */
-export var ServiceLifecycle;
-(function (ServiceLifecycle) {
-    /** Single instance shared across all requests */
-    ServiceLifecycle["SINGLETON"] = "singleton";
-    /** New instance created for each request */
-    ServiceLifecycle["TRANSIENT"] = "transient";
-    /** New instance per scope (e.g., per HTTP request) */
-    ServiceLifecycle["SCOPED"] = "scoped";
-})(ServiceLifecycle || (ServiceLifecycle = {}));
-/**
- * Enhanced Plugin Loader
- * Provides advanced plugin loading capabilities with validation, security, and lifecycle management
- */
-export class PluginLoader {
-    constructor(logger) {
-        this.loadedPlugins = new Map();
-        this.serviceFactories = new Map();
-        this.serviceInstances = new Map();
-        this.scopedServices = new Map();
-        this.creating = new Set();
-        this.logger = logger;
-        this.configValidator = new PluginConfigValidator(logger);
-    }
-    /**
-     * Set the plugin context for service factories
-     */
-    setContext(context) {
-        this.context = context;
-    }
-    /**
-     * Get a synchronous service instance if it exists (Sync Helper)
-     */
-    getServiceInstance(name) {
-        return this.serviceInstances.get(name);
-    }
-    /**
-     * Load a plugin asynchronously with validation
-     */
-    async loadPlugin(plugin) {
-        const startTime = Date.now();
-        try {
-            this.logger.info(`Loading plugin: ${plugin.name}`);
-            // Convert to PluginMetadata
-            const metadata = this.toPluginMetadata(plugin);
-            // Validate plugin structure
-            this.validatePluginStructure(metadata);
-            // Check version compatibility
-            const versionCheck = this.checkVersionCompatibility(metadata);
-            if (!versionCheck.compatible) {
-                throw new Error(`Version incompatible: ${versionCheck.message}`);
-            }
-            // Validate configuration if schema is provided
-            if (metadata.configSchema) {
-                this.validatePluginConfig(metadata);
-            }
-            // Verify signature if provided
-            if (metadata.signature) {
-                await this.verifyPluginSignature(metadata);
-            }
-            // Store loaded plugin
-            this.loadedPlugins.set(metadata.name, metadata);
-            const loadTime = Date.now() - startTime;
-            this.logger.info(`Plugin loaded: ${plugin.name} (${loadTime}ms)`);
-            return {
-                success: true,
-                plugin: metadata,
-                loadTime,
-            };
-        }
-        catch (error) {
-            this.logger.error(`Failed to load plugin: ${plugin.name}`, error);
-            return {
-                success: false,
-                error: error,
-                loadTime: Date.now() - startTime,
-            };
-        }
-    }
-    /**
-     * Register a service with factory function
-     */
-    registerServiceFactory(registration) {
-        if (this.serviceFactories.has(registration.name)) {
-            throw new Error(`Service factory '${registration.name}' already registered`);
-        }
-        this.serviceFactories.set(registration.name, registration);
-        this.logger.debug(`Service factory registered: ${registration.name} (${registration.lifecycle})`);
-    }
-    /**
-     * Get or create a service instance based on lifecycle type
-     */
-    async getService(name, scopeId) {
-        const registration = this.serviceFactories.get(name);
-        if (!registration) {
-            // Fall back to static service instances
-            const instance = this.serviceInstances.get(name);
-            if (!instance) {
-                throw new Error(`Service '${name}' not found`);
-            }
-            return instance;
-        }
-        switch (registration.lifecycle) {
-            case ServiceLifecycle.SINGLETON:
-                return await this.getSingletonService(registration);
-            case ServiceLifecycle.TRANSIENT:
-                return await this.createTransientService(registration);
-            case ServiceLifecycle.SCOPED:
-                if (!scopeId) {
-                    throw new Error(`Scope ID required for scoped service '${name}'`);
-                }
-                return await this.getScopedService(registration, scopeId);
-            default:
-                throw new Error(`Unknown service lifecycle: ${registration.lifecycle}`);
-        }
-    }
-    /**
-     * Register a static service instance (legacy support)
-     */
-    registerService(name, service) {
-        if (this.serviceInstances.has(name)) {
-            throw new Error(`Service '${name}' already registered`);
-        }
-        this.serviceInstances.set(name, service);
-    }
-    /**
-     * Check if a service is registered (either as instance or factory)
-     */
-    hasService(name) {
-        return this.serviceInstances.has(name) || this.serviceFactories.has(name);
-    }
-    /**
-     * Detect circular dependencies in service factories
-     * Note: This only detects cycles in service dependencies, not plugin dependencies.
-     * Plugin dependency cycles are detected in the kernel's resolveDependencies method.
-     */
-    detectCircularDependencies() {
-        const cycles = [];
-        const visited = new Set();
-        const visiting = new Set();
-        const visit = (serviceName, path = []) => {
-            if (visiting.has(serviceName)) {
-                const cycle = [...path, serviceName].join(' -> ');
-                cycles.push(cycle);
-                return;
-            }
-            if (visited.has(serviceName)) {
-                return;
-            }
-            visiting.add(serviceName);
-            const registration = this.serviceFactories.get(serviceName);
-            if (registration?.dependencies) {
-                for (const dep of registration.dependencies) {
-                    visit(dep, [...path, serviceName]);
-                }
-            }
-            visiting.delete(serviceName);
-            visited.add(serviceName);
-        };
-        for (const serviceName of this.serviceFactories.keys()) {
-            visit(serviceName);
-        }
-        return cycles;
-    }
-    /**
-     * Check plugin health
-     */
-    async checkPluginHealth(pluginName) {
-        const plugin = this.loadedPlugins.get(pluginName);
-        if (!plugin) {
-            return {
-                healthy: false,
-                message: 'Plugin not found',
-                lastCheck: new Date(),
-            };
-        }
-        if (!plugin.healthCheck) {
-            return {
-                healthy: true,
-                message: 'No health check defined',
-                lastCheck: new Date(),
-            };
-        }
-        try {
-            const status = await plugin.healthCheck();
-            return {
-                ...status,
-                lastCheck: new Date(),
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                message: `Health check failed: ${error.message}`,
-                lastCheck: new Date(),
-            };
-        }
-    }
-    /**
-     * Clear scoped services for a scope
-     */
-    clearScope(scopeId) {
-        this.scopedServices.delete(scopeId);
-        this.logger.debug(`Cleared scope: ${scopeId}`);
-    }
-    /**
-     * Get all loaded plugins
-     */
-    getLoadedPlugins() {
-        return new Map(this.loadedPlugins);
-    }
-    // Private helper methods
-    toPluginMetadata(plugin) {
-        return {
-            ...plugin,
-            version: plugin.version || '0.0.0',
-        };
-    }
-    validatePluginStructure(plugin) {
-        if (!plugin.name) {
-            throw new Error('Plugin name is required');
-        }
-        if (!plugin.init) {
-            throw new Error('Plugin init function is required');
-        }
-        if (!this.isValidSemanticVersion(plugin.version)) {
-            throw new Error(`Invalid semantic version: ${plugin.version}`);
-        }
-    }
-    checkVersionCompatibility(plugin) {
-        // Basic semantic version compatibility check
-        // In a real implementation, this would check against kernel version
-        const version = plugin.version;
-        if (!this.isValidSemanticVersion(version)) {
-            return {
-                compatible: false,
-                pluginVersion: version,
-                message: 'Invalid semantic version format',
-            };
-        }
-        return {
-            compatible: true,
-            pluginVersion: version,
-        };
-    }
-    isValidSemanticVersion(version) {
-        const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
-        return semverRegex.test(version);
-    }
-    validatePluginConfig(plugin, config) {
-        if (!plugin.configSchema) {
-            return;
-        }
-        if (config === undefined) {
-            // In loadPlugin, we often don't have the config yet.
-            // We skip validation here or valid against empty object if schema allows?
-            // For now, let's keep the logging behavior but note it's delegating
-            this.logger.debug(`Plugin ${plugin.name} has configuration schema (config validation postponed)`);
-            return;
-        }
-        this.configValidator.validatePluginConfig(plugin, config);
-    }
-    async verifyPluginSignature(plugin) {
-        if (!plugin.signature) {
-            return;
-        }
-        // Plugin signature verification is now implemented in PluginSignatureVerifier
-        // This is a placeholder that logs the verification would happen
-        // The actual verification should be done by the caller with proper security config
-        this.logger.debug(`Plugin ${plugin.name} has signature (use PluginSignatureVerifier for verification)`);
-    }
-    async getSingletonService(registration) {
-        let instance = this.serviceInstances.get(registration.name);
-        if (!instance) {
-            // Create instance (would need context)
-            instance = await this.createServiceInstance(registration);
-            this.serviceInstances.set(registration.name, instance);
-            this.logger.debug(`Singleton service created: ${registration.name}`);
-        }
-        return instance;
-    }
-    async createTransientService(registration) {
-        const instance = await this.createServiceInstance(registration);
-        this.logger.debug(`Transient service created: ${registration.name}`);
-        return instance;
-    }
-    async getScopedService(registration, scopeId) {
-        if (!this.scopedServices.has(scopeId)) {
-            this.scopedServices.set(scopeId, new Map());
-        }
-        const scope = this.scopedServices.get(scopeId);
-        let instance = scope.get(registration.name);
-        if (!instance) {
-            instance = await this.createServiceInstance(registration);
-            scope.set(registration.name, instance);
-            this.logger.debug(`Scoped service created: ${registration.name} (scope: ${scopeId})`);
-        }
-        return instance;
-    }
-    async createServiceInstance(registration) {
-        if (!this.context) {
-            throw new Error(`[PluginLoader] Context not set - cannot create service '${registration.name}'`);
-        }
-        if (this.creating.has(registration.name)) {
-            throw new Error(`Circular dependency detected: ${Array.from(this.creating).join(' -> ')} -> ${registration.name}`);
-        }
-        this.creating.add(registration.name);
-        try {
-            return await registration.factory(this.context);
-        }
-        finally {
-            this.creating.delete(registration.name);
-        }
-    }
-}

package/dist/plugin-loader.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=plugin-loader.test.d.ts.map

package/dist/plugin-loader.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-loader.test.d.ts","sourceRoot":"","sources":["../src/plugin-loader.test.ts"],"names":[],"mappings":""}