@objectstack/core 0.9.1 → 0.9.2

package/dist/api-registry-plugin.test.js

@@ -9,7 +9,7 @@ describe('API Registry Plugin', () => {
     });
     describe('Plugin Registration', () => {
         it('should register API Registry as a service', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             await kernel.bootstrap();
             const registry = kernel.getService('api-registry');
             expect(registry).toBeDefined();
@@ -17,7 +17,7 @@ describe('API Registry Plugin', () => {
             await kernel.shutdown();
         });
         it('should register with custom conflict resolution', async () => {
-            kernel.use(createApiRegistryPlugin({
+            await kernel.use(createApiRegistryPlugin({
                 conflictResolution: 'priority',
                 version: '2.0.0',
             }));
@@ -31,7 +31,7 @@ describe('API Registry Plugin', () => {
     });
     describe('Integration with Plugins', () => {
         it('should allow plugins to register APIs', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             const testPlugin = {
                 name: 'test-plugin',
                 init: async (ctx) => {
@@ -60,7 +60,7 @@ describe('API Registry Plugin', () => {
                     registry.registerApi(api);
                 },
             };
-            kernel.use(testPlugin);
+            await kernel.use(testPlugin);
             await kernel.bootstrap();
             const registry = kernel.getService('api-registry');
             const api = registry.getApi('test_api');
@@ -70,7 +70,7 @@ describe('API Registry Plugin', () => {
             await kernel.shutdown();
         });
         it('should allow multiple plugins to register APIs', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             const plugin1 = {
                 name: 'plugin-1',
                 init: async (ctx) => {
@@ -112,8 +112,8 @@ describe('API Registry Plugin', () => {
                     });
                 },
             };
-            kernel.use(plugin1);
-            kernel.use(plugin2);
+            await kernel.use(plugin1);
+            await kernel.use(plugin2);
             await kernel.bootstrap();
             const registry = kernel.getService('api-registry');
             const stats = registry.getStats();
@@ -123,7 +123,7 @@ describe('API Registry Plugin', () => {
             await kernel.shutdown();
         });
         it('should support API discovery across plugins', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             const dataPlugin = {
                 name: 'data-plugin',
                 init: async (ctx) => {
@@ -172,8 +172,8 @@ describe('API Registry Plugin', () => {
                     });
                 },
             };
-            kernel.use(dataPlugin);
-            kernel.use(analyticsPlugin);
+            await kernel.use(dataPlugin);
+            await kernel.use(analyticsPlugin);
             await kernel.bootstrap();
             const registry = kernel.getService('api-registry');
             // Find all data APIs
@@ -189,7 +189,7 @@ describe('API Registry Plugin', () => {
             await kernel.shutdown();
         });
         it('should handle route conflicts based on strategy', async () => {
-            kernel.use(createApiRegistryPlugin({
+            await kernel.use(createApiRegistryPlugin({
                 conflictResolution: 'priority',
             }));
             const corePlugin = {
@@ -238,8 +238,8 @@ describe('API Registry Plugin', () => {
                     });
                 },
             };
-            kernel.use(corePlugin);
-            kernel.use(pluginOverride);
+            await kernel.use(corePlugin);
+            await kernel.use(pluginOverride);
             await kernel.bootstrap();
             const registry = kernel.getService('api-registry');
             const result = registry.findEndpointByRoute('GET', '/api/data/:object');
@@ -249,7 +249,7 @@ describe('API Registry Plugin', () => {
             await kernel.shutdown();
         });
         it('should support cleanup on plugin unload', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             const dynamicPlugin = {
                 name: 'dynamic-plugin',
                 init: async (ctx) => {
@@ -275,7 +275,7 @@ describe('API Registry Plugin', () => {
                     // For now, we'll test the registry's unregister capability
                 },
             };
-            kernel.use(dynamicPlugin);
+            await kernel.use(dynamicPlugin);
             await kernel.bootstrap();
             const registry = kernel.getService('api-registry');
             expect(registry.getApi('dynamic_api')).toBeDefined();
@@ -287,7 +287,7 @@ describe('API Registry Plugin', () => {
     });
     describe('API Registry Lifecycle', () => {
         it('should be available during plugin start phase', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             let registryAvailable = false;
             const testPlugin = {
                 name: 'test-plugin',
@@ -300,13 +300,13 @@ describe('API Registry Plugin', () => {
                     registryAvailable = registry !== undefined;
                 },
             };
-            kernel.use(testPlugin);
+            await kernel.use(testPlugin);
             await kernel.bootstrap();
             expect(registryAvailable).toBe(true);
             await kernel.shutdown();
         });
         it('should provide consistent registry across all plugins', async () => {
-            kernel.use(createApiRegistryPlugin());
+            await kernel.use(createApiRegistryPlugin());
             let registry1;
             let registry2;
             const plugin1 = {
@@ -321,8 +321,8 @@ describe('API Registry Plugin', () => {
                     registry2 = ctx.getService('api-registry');
                 },
             };
-            kernel.use(plugin1);
-            kernel.use(plugin2);
+            await kernel.use(plugin1);
+            await kernel.use(plugin2);
             await kernel.bootstrap();
             // Same registry instance should be shared
             expect(registry1).toBe(registry2);

package/dist/dependency-resolver.d.ts

@@ -0,0 +1,62 @@
+import type { SemanticVersion, VersionConstraint, CompatibilityLevel, DependencyConflict } from '@objectstack/spec/system';
+import type { ObjectLogger } from './logger.js';
+/**
+ * Semantic Version Parser and Comparator
+ *
+ * Implements semantic versioning comparison and constraint matching
+ */
+export declare class SemanticVersionManager {
+    /**
+     * Parse a version string into semantic version components
+     */
+    static parse(versionStr: string): SemanticVersion;
+    /**
+     * Convert semantic version back to string
+     */
+    static toString(version: SemanticVersion): string;
+    /**
+     * Compare two semantic versions
+     * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+     */
+    static compare(a: SemanticVersion, b: SemanticVersion): number;
+    /**
+     * Check if version satisfies constraint
+     */
+    static satisfies(version: SemanticVersion, constraint: VersionConstraint): boolean;
+    /**
+     * Determine compatibility level between two versions
+     */
+    static getCompatibilityLevel(from: SemanticVersion, to: SemanticVersion): CompatibilityLevel;
+}
+/**
+ * Plugin Dependency Resolver
+ *
+ * Resolves plugin dependencies using topological sorting and conflict detection
+ */
+export declare class DependencyResolver {
+    private logger;
+    constructor(logger: ObjectLogger);
+    /**
+     * Resolve dependencies using topological sort
+     */
+    resolve(plugins: Map<string, {
+        version?: string;
+        dependencies?: string[];
+    }>): string[];
+    /**
+     * Detect dependency conflicts
+     */
+    detectConflicts(plugins: Map<string, {
+        version: string;
+        dependencies?: Record<string, VersionConstraint>;
+    }>): DependencyConflict[];
+    /**
+     * Find best version that satisfies all constraints
+     */
+    findBestVersion(availableVersions: string[], constraints: VersionConstraint[]): string | undefined;
+    /**
+     * Check if dependencies form a valid DAG (no cycles)
+     */
+    isAcyclic(dependencies: Map<string, string[]>): boolean;
+}
+//# sourceMappingURL=dependency-resolver.d.ts.map

package/dist/dependency-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-resolver.d.ts","sourceRoot":"","sources":["../src/dependency-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;GAIG;AACH,qBAAa,sBAAsB;IACjC;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe;IAsBjD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM;IAWjD;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM;IAkB9D;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,iBAAiB,GAAG,OAAO;IAoElF;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE,eAAe,GAAG,kBAAkB;CA0B7F;AAED;;;;GAIG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,YAAY;IAIhC;;OAEG;IACH,OAAO,CACL,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,GAClE,MAAM,EAAE;IAkEX;;OAEG;IACH,eAAe,CACb,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;KAAE,CAAC,GAC1F,kBAAkB,EAAE;IA+EvB;;OAEG;IACH,eAAe,CACb,iBAAiB,EAAE,MAAM,EAAE,EAC3B,WAAW,EAAE,iBAAiB,EAAE,GAC/B,MAAM,GAAG,SAAS;IAoBrB;;OAEG;IACH,SAAS,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO;CAcxD"}

package/dist/dependency-resolver.js

@@ -0,0 +1,317 @@
+/**
+ * Semantic Version Parser and Comparator
+ *
+ * Implements semantic versioning comparison and constraint matching
+ */
+export class SemanticVersionManager {
+    /**
+     * Parse a version string into semantic version components
+     */
+    static parse(versionStr) {
+        // Remove 'v' prefix if present
+        const cleanVersion = versionStr.replace(/^v/, '');
+        // Match semver pattern: major.minor.patch[-prerelease][+build]
+        const match = cleanVersion.match(/^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+))?(?:\+([a-zA-Z0-9.-]+))?$/);
+        if (!match) {
+            throw new Error(`Invalid semantic version: ${versionStr}`);
+        }
+        return {
+            major: parseInt(match[1], 10),
+            minor: parseInt(match[2], 10),
+            patch: parseInt(match[3], 10),
+            preRelease: match[4],
+            build: match[5],
+        };
+    }
+    /**
+     * Convert semantic version back to string
+     */
+    static toString(version) {
+        let str = `${version.major}.${version.minor}.${version.patch}`;
+        if (version.preRelease) {
+            str += `-${version.preRelease}`;
+        }
+        if (version.build) {
+            str += `+${version.build}`;
+        }
+        return str;
+    }
+    /**
+     * Compare two semantic versions
+     * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+     */
+    static compare(a, b) {
+        // Compare major, minor, patch
+        if (a.major !== b.major)
+            return a.major - b.major;
+        if (a.minor !== b.minor)
+            return a.minor - b.minor;
+        if (a.patch !== b.patch)
+            return a.patch - b.patch;
+        // Pre-release versions have lower precedence
+        if (a.preRelease && !b.preRelease)
+            return -1;
+        if (!a.preRelease && b.preRelease)
+            return 1;
+        // Compare pre-release versions
+        if (a.preRelease && b.preRelease) {
+            return a.preRelease.localeCompare(b.preRelease);
+        }
+        return 0;
+    }
+    /**
+     * Check if version satisfies constraint
+     */
+    static satisfies(version, constraint) {
+        const constraintStr = constraint;
+        // Any version
+        if (constraintStr === '*' || constraintStr === 'latest') {
+            return true;
+        }
+        // Exact version
+        if (/^[\d.]+$/.test(constraintStr)) {
+            const exact = this.parse(constraintStr);
+            return this.compare(version, exact) === 0;
+        }
+        // Caret range (^): Compatible with version
+        if (constraintStr.startsWith('^')) {
+            const base = this.parse(constraintStr.slice(1));
+            return (version.major === base.major &&
+                this.compare(version, base) >= 0);
+        }
+        // Tilde range (~): Approximately equivalent
+        if (constraintStr.startsWith('~')) {
+            const base = this.parse(constraintStr.slice(1));
+            return (version.major === base.major &&
+                version.minor === base.minor &&
+                this.compare(version, base) >= 0);
+        }
+        // Greater than or equal
+        if (constraintStr.startsWith('>=')) {
+            const base = this.parse(constraintStr.slice(2));
+            return this.compare(version, base) >= 0;
+        }
+        // Greater than
+        if (constraintStr.startsWith('>')) {
+            const base = this.parse(constraintStr.slice(1));
+            return this.compare(version, base) > 0;
+        }
+        // Less than or equal
+        if (constraintStr.startsWith('<=')) {
+            const base = this.parse(constraintStr.slice(2));
+            return this.compare(version, base) <= 0;
+        }
+        // Less than
+        if (constraintStr.startsWith('<')) {
+            const base = this.parse(constraintStr.slice(1));
+            return this.compare(version, base) < 0;
+        }
+        // Range (1.2.3 - 2.3.4)
+        const rangeMatch = constraintStr.match(/^([\d.]+)\s*-\s*([\d.]+)$/);
+        if (rangeMatch) {
+            const min = this.parse(rangeMatch[1]);
+            const max = this.parse(rangeMatch[2]);
+            return this.compare(version, min) >= 0 && this.compare(version, max) <= 0;
+        }
+        return false;
+    }
+    /**
+     * Determine compatibility level between two versions
+     */
+    static getCompatibilityLevel(from, to) {
+        const cmp = this.compare(from, to);
+        // Same version
+        if (cmp === 0) {
+            return 'fully-compatible';
+        }
+        // Major version changed - breaking changes
+        if (from.major !== to.major) {
+            return 'breaking-changes';
+        }
+        // Minor version increased - backward compatible
+        if (from.minor < to.minor) {
+            return 'backward-compatible';
+        }
+        // Patch version increased - fully compatible
+        if (from.patch < to.patch) {
+            return 'fully-compatible';
+        }
+        // Downgrade - incompatible
+        return 'incompatible';
+    }
+}
+/**
+ * Plugin Dependency Resolver
+ *
+ * Resolves plugin dependencies using topological sorting and conflict detection
+ */
+export class DependencyResolver {
+    constructor(logger) {
+        this.logger = logger.child({ component: 'DependencyResolver' });
+    }
+    /**
+     * Resolve dependencies using topological sort
+     */
+    resolve(plugins) {
+        const graph = new Map();
+        const inDegree = new Map();
+        // Build dependency graph
+        for (const [pluginName, pluginInfo] of plugins) {
+            if (!graph.has(pluginName)) {
+                graph.set(pluginName, []);
+                inDegree.set(pluginName, 0);
+            }
+            const deps = pluginInfo.dependencies || [];
+            for (const dep of deps) {
+                // Check if dependency exists
+                if (!plugins.has(dep)) {
+                    throw new Error(`Missing dependency: ${pluginName} requires ${dep}`);
+                }
+                // Add edge
+                if (!graph.has(dep)) {
+                    graph.set(dep, []);
+                    inDegree.set(dep, 0);
+                }
+                graph.get(dep).push(pluginName);
+                inDegree.set(pluginName, (inDegree.get(pluginName) || 0) + 1);
+            }
+        }
+        // Topological sort using Kahn's algorithm
+        const queue = [];
+        const result = [];
+        // Add all nodes with no incoming edges
+        for (const [node, degree] of inDegree) {
+            if (degree === 0) {
+                queue.push(node);
+            }
+        }
+        while (queue.length > 0) {
+            const node = queue.shift();
+            result.push(node);
+            // Reduce in-degree for dependent nodes
+            const dependents = graph.get(node) || [];
+            for (const dependent of dependents) {
+                const newDegree = (inDegree.get(dependent) || 0) - 1;
+                inDegree.set(dependent, newDegree);
+                if (newDegree === 0) {
+                    queue.push(dependent);
+                }
+            }
+        }
+        // Check for circular dependencies
+        if (result.length !== plugins.size) {
+            const remaining = Array.from(plugins.keys()).filter(p => !result.includes(p));
+            this.logger.error('Circular dependency detected', { remaining });
+            throw new Error(`Circular dependency detected among: ${remaining.join(', ')}`);
+        }
+        this.logger.debug('Dependencies resolved', { order: result });
+        return result;
+    }
+    /**
+     * Detect dependency conflicts
+     */
+    detectConflicts(plugins) {
+        const conflicts = [];
+        const versionRequirements = new Map();
+        // Collect all version requirements
+        for (const [pluginName, pluginInfo] of plugins) {
+            if (!pluginInfo.dependencies)
+                continue;
+            for (const [depName, constraint] of Object.entries(pluginInfo.dependencies)) {
+                if (!versionRequirements.has(depName)) {
+                    versionRequirements.set(depName, new Map());
+                }
+                versionRequirements.get(depName).set(pluginName, constraint);
+            }
+        }
+        // Check for version mismatches
+        for (const [depName, requirements] of versionRequirements) {
+            const depInfo = plugins.get(depName);
+            if (!depInfo)
+                continue;
+            const depVersion = SemanticVersionManager.parse(depInfo.version);
+            const unsatisfied = [];
+            for (const [requiringPlugin, constraint] of requirements) {
+                if (!SemanticVersionManager.satisfies(depVersion, constraint)) {
+                    unsatisfied.push({
+                        pluginId: requiringPlugin,
+                        version: constraint,
+                    });
+                }
+            }
+            if (unsatisfied.length > 0) {
+                conflicts.push({
+                    type: 'version-mismatch',
+                    severity: 'error',
+                    description: `Version mismatch for ${depName}: detected ${unsatisfied.length} unsatisfied requirements`,
+                    plugins: [
+                        { pluginId: depName, version: depInfo.version },
+                        ...unsatisfied,
+                    ],
+                    resolutions: [{
+                            strategy: 'upgrade',
+                            description: `Upgrade ${depName} to satisfy all constraints`,
+                            targetPlugins: [depName],
+                            automatic: false,
+                        }],
+                });
+            }
+        }
+        // Check for circular dependencies (will be caught by resolve())
+        try {
+            this.resolve(new Map(Array.from(plugins.entries()).map(([name, info]) => [
+                name,
+                { version: info.version, dependencies: info.dependencies ? Object.keys(info.dependencies) : [] }
+            ])));
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Circular dependency')) {
+                conflicts.push({
+                    type: 'circular-dependency',
+                    severity: 'critical',
+                    description: error.message,
+                    plugins: [], // Would need to extract from error
+                    resolutions: [{
+                            strategy: 'manual',
+                            description: 'Remove circular dependency by restructuring plugins',
+                            automatic: false,
+                        }],
+                });
+            }
+        }
+        return conflicts;
+    }
+    /**
+     * Find best version that satisfies all constraints
+     */
+    findBestVersion(availableVersions, constraints) {
+        // Parse and sort versions (highest first)
+        const versions = availableVersions
+            .map(v => ({ str: v, parsed: SemanticVersionManager.parse(v) }))
+            .sort((a, b) => -SemanticVersionManager.compare(a.parsed, b.parsed));
+        // Find highest version that satisfies all constraints
+        for (const version of versions) {
+            const satisfiesAll = constraints.every(constraint => SemanticVersionManager.satisfies(version.parsed, constraint));
+            if (satisfiesAll) {
+                return version.str;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check if dependencies form a valid DAG (no cycles)
+     */
+    isAcyclic(dependencies) {
+        try {
+            const plugins = new Map(Array.from(dependencies.entries()).map(([name, deps]) => [
+                name,
+                { dependencies: deps }
+            ]));
+            this.resolve(plugins);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/dependency-resolver.test.d.ts

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

package/dist/dependency-resolver.test.d.ts.map

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