@objectstack/core 4.0.4 → 4.0.5

package/src/dependency-resolver.ts

@@ -1,390 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { 
-  SemanticVersion,
-  VersionConstraint,
-  CompatibilityLevel,
-  DependencyConflict
-} from '@objectstack/spec/kernel';
-import type { ObjectLogger } from './logger.js';
-
-/**
- * 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: string): SemanticVersion {
-    // 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: SemanticVersion): string {
-    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: SemanticVersion, b: SemanticVersion): number {
-    // 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: SemanticVersion, constraint: VersionConstraint): boolean {
-    const constraintStr = constraint as string;
-
-    // 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: SemanticVersion, to: SemanticVersion): CompatibilityLevel {
-    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 {
-  private logger: ObjectLogger;
-
-  constructor(logger: ObjectLogger) {
-    this.logger = logger.child({ component: 'DependencyResolver' });
-  }
-
-  /**
-   * Resolve dependencies using topological sort
-   */
-  resolve(
-    plugins: Map<string, { version?: string; dependencies?: string[] }>
-  ): string[] {
-    const graph = new Map<string, string[]>();
-    const inDegree = new Map<string, number>();
-
-    // 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: string[] = [];
-    const result: string[] = [];
-
-    // 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: Map<string, { version: string; dependencies?: Record<string, VersionConstraint> }>
-  ): DependencyConflict[] {
-    const conflicts: DependencyConflict[] = [];
-    const versionRequirements = new Map<string, Map<string, VersionConstraint>>();
-
-    // 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: Array<{ pluginId: string; version: string }> = [];
-
-      for (const [requiringPlugin, constraint] of requirements) {
-        if (!SemanticVersionManager.satisfies(depVersion, constraint)) {
-          unsatisfied.push({
-            pluginId: requiringPlugin,
-            version: constraint as string,
-          });
-        }
-      }
-
-      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,
-          } as any],
-        });
-      }
-    }
-
-    // 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,
-          } as any],
-        });
-      }
-    }
-
-    return conflicts;
-  }
-
-  /**
-   * Find best version that satisfies all constraints
-   */
-  findBestVersion(
-    availableVersions: string[],
-    constraints: VersionConstraint[]
-  ): string | undefined {
-    // 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: Map<string, string[]>): boolean {
-    try {
-      const plugins = new Map(
-        Array.from(dependencies.entries()).map(([name, deps]) => [
-          name,
-          { dependencies: deps }
-        ])
-      );
-      this.resolve(plugins);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}

package/src/fallbacks/fallbacks.test.ts

@@ -1,281 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createMemoryCache } from './memory-cache';
-import { createMemoryQueue } from './memory-queue';
-import { createMemoryJob } from './memory-job';
-import { createMemoryI18n, resolveLocale } from './memory-i18n';
-import { CORE_FALLBACK_FACTORIES } from './index';
-
-describe('CORE_FALLBACK_FACTORIES', () => {
-    it('should have exactly 5 entries: metadata, cache, queue, job, i18n', () => {
-        expect(Object.keys(CORE_FALLBACK_FACTORIES)).toEqual(['metadata', 'cache', 'queue', 'job', 'i18n']);
-    });
-
-    it('should map to factory functions', () => {
-        for (const factory of Object.values(CORE_FALLBACK_FACTORIES)) {
-            expect(typeof factory).toBe('function');
-        }
-    });
-});
-
-describe('createMemoryCache', () => {
-    it('should return an object with _fallback: true', () => {
-        const cache = createMemoryCache();
-        expect(cache._fallback).toBe(true);
-        expect(cache._serviceName).toBe('cache');
-    });
-
-    it('should set and get a value', async () => {
-        const cache = createMemoryCache();
-        await cache.set('key1', 'value1');
-        expect(await cache.get('key1')).toBe('value1');
-    });
-
-    it('should return undefined for missing key', async () => {
-        const cache = createMemoryCache();
-        expect(await cache.get('nonexistent')).toBeUndefined();
-    });
-
-    it('should delete a key', async () => {
-        const cache = createMemoryCache();
-        await cache.set('key1', 'value1');
-        expect(await cache.delete('key1')).toBe(true);
-        expect(await cache.get('key1')).toBeUndefined();
-    });
-
-    it('should check if a key exists with has()', async () => {
-        const cache = createMemoryCache();
-        expect(await cache.has('key1')).toBe(false);
-        await cache.set('key1', 'value1');
-        expect(await cache.has('key1')).toBe(true);
-    });
-
-    it('should clear all entries', async () => {
-        const cache = createMemoryCache();
-        await cache.set('a', 1);
-        await cache.set('b', 2);
-        await cache.clear();
-        expect(await cache.has('a')).toBe(false);
-        expect(await cache.has('b')).toBe(false);
-    });
-
-    it('should expire entries based on TTL', async () => {
-        const cache = createMemoryCache();
-        // Set with very short TTL (0.001 seconds = 1ms)
-        await cache.set('temp', 'data', 0.001);
-        // Wait for expiry
-        await new Promise(r => setTimeout(r, 20));
-        expect(await cache.get('temp')).toBeUndefined();
-    });
-
-    it('should track hit/miss stats', async () => {
-        const cache = createMemoryCache();
-        await cache.set('key1', 'value1');
-        await cache.get('key1');      // hit
-        await cache.get('missing');   // miss
-        const stats = await cache.stats();
-        expect(stats.hits).toBe(1);
-        expect(stats.misses).toBe(1);
-        expect(stats.keyCount).toBe(1);
-    });
-});
-
-describe('createMemoryQueue', () => {
-    it('should return an object with _fallback: true', () => {
-        const queue = createMemoryQueue();
-        expect(queue._fallback).toBe(true);
-        expect(queue._serviceName).toBe('queue');
-    });
-
-    it('should publish and deliver to subscriber synchronously', async () => {
-        const queue = createMemoryQueue();
-        const received: any[] = [];
-        await queue.subscribe('test-q', async (msg: any) => { received.push(msg); });
-        const id = await queue.publish('test-q', { hello: 'world' });
-        expect(id).toMatch(/^fallback-msg-/);
-        expect(received).toHaveLength(1);
-        expect(received[0].data).toEqual({ hello: 'world' });
-    });
-
-    it('should not deliver to unsubscribed queue', async () => {
-        const queue = createMemoryQueue();
-        const received: any[] = [];
-        await queue.subscribe('q1', async (msg: any) => { received.push(msg); });
-        await queue.unsubscribe('q1');
-        await queue.publish('q1', 'data');
-        expect(received).toHaveLength(0);
-    });
-
-    it('should return queue size of 0', async () => {
-        const queue = createMemoryQueue();
-        expect(await queue.getQueueSize()).toBe(0);
-    });
-
-    it('should purge a queue', async () => {
-        const queue = createMemoryQueue();
-        const received: any[] = [];
-        await queue.subscribe('q1', async (msg: any) => { received.push(msg); });
-        await queue.purge('q1');
-        await queue.publish('q1', 'data');
-        expect(received).toHaveLength(0);
-    });
-});
-
-describe('createMemoryJob', () => {
-    it('should return an object with _fallback: true', () => {
-        const job = createMemoryJob();
-        expect(job._fallback).toBe(true);
-        expect(job._serviceName).toBe('job');
-    });
-
-    it('should schedule and list jobs', async () => {
-        const job = createMemoryJob();
-        await job.schedule('daily-report', '0 0 * * *', async () => {});
-        expect(await job.listJobs()).toEqual(['daily-report']);
-    });
-
-    it('should cancel a job', async () => {
-        const job = createMemoryJob();
-        await job.schedule('temp-job', '* * * * *', async () => {});
-        await job.cancel('temp-job');
-        expect(await job.listJobs()).toEqual([]);
-    });
-
-    it('should trigger a job handler', async () => {
-        const job = createMemoryJob();
-        let triggered = false;
-        await job.schedule('my-job', '* * * * *', async (ctx: any) => {
-            triggered = true;
-            expect(ctx.jobId).toBe('my-job');
-            expect(ctx.data).toEqual({ key: 'val' });
-        });
-        await job.trigger('my-job', { key: 'val' });
-        expect(triggered).toBe(true);
-    });
-
-    it('should return empty executions', async () => {
-        const job = createMemoryJob();
-        expect(await job.getExecutions()).toEqual([]);
-    });
-});
-
-describe('createMemoryI18n', () => {
-    it('should return an object with _fallback: true', () => {
-        const i18n = createMemoryI18n();
-        expect(i18n._fallback).toBe(true);
-        expect(i18n._serviceName).toBe('i18n');
-    });
-
-    it('should return the key when no translations are loaded', () => {
-        const i18n = createMemoryI18n();
-        expect(i18n.t('objects.account.label', 'en')).toBe('objects.account.label');
-    });
-
-    it('should translate after loading translations', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('en', { objects: { account: { label: 'Account' } } });
-        expect(i18n.t('objects.account.label', 'en')).toBe('Account');
-    });
-
-    it('should interpolate parameters', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('en', { greeting: 'Hello, {{name}}!' });
-        expect(i18n.t('greeting', 'en', { name: 'World' })).toBe('Hello, World!');
-    });
-
-    it('should fall back to default locale', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('en', { hello: 'Hello' });
-        // 'fr' has no translations, should fall back to default 'en'
-        expect(i18n.t('hello', 'fr')).toBe('Hello');
-    });
-
-    it('should get and set default locale', () => {
-        const i18n = createMemoryI18n();
-        expect(i18n.getDefaultLocale()).toBe('en');
-        i18n.setDefaultLocale('zh-CN');
-        expect(i18n.getDefaultLocale()).toBe('zh-CN');
-    });
-
-    it('should list loaded locales', () => {
-        const i18n = createMemoryI18n();
-        expect(i18n.getLocales()).toEqual([]);
-        i18n.loadTranslations('en', { hello: 'Hello' });
-        i18n.loadTranslations('zh-CN', { hello: '你好' });
-        expect(i18n.getLocales()).toEqual(['en', 'zh-CN']);
-    });
-
-    it('should get all translations for a locale', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('en', { hello: 'Hello', bye: 'Goodbye' });
-        expect(i18n.getTranslations('en')).toEqual({ hello: 'Hello', bye: 'Goodbye' });
-    });
-
-    it('should return empty object for unknown locale', () => {
-        const i18n = createMemoryI18n();
-        expect(i18n.getTranslations('unknown')).toEqual({});
-    });
-
-    it('should merge translations on subsequent loads', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('en', { hello: 'Hello' });
-        i18n.loadTranslations('en', { bye: 'Goodbye' });
-        expect(i18n.getTranslations('en')).toEqual({ hello: 'Hello', bye: 'Goodbye' });
-    });
-});
-
-describe('resolveLocale', () => {
-    it('should return exact match', () => {
-        expect(resolveLocale('zh-CN', ['en', 'zh-CN', 'ja'])).toBe('zh-CN');
-    });
-
-    it('should return case-insensitive match', () => {
-        expect(resolveLocale('zh-cn', ['en', 'zh-CN'])).toBe('zh-CN');
-        expect(resolveLocale('EN-US', ['en-US', 'zh-CN'])).toBe('en-US');
-    });
-
-    it('should return base language match', () => {
-        expect(resolveLocale('zh-TW', ['en', 'zh'])).toBe('zh');
-    });
-
-    it('should return variant expansion (zh → zh-CN)', () => {
-        expect(resolveLocale('zh', ['en', 'zh-CN', 'zh-TW'])).toBe('zh-CN');
-    });
-
-    it('should return undefined for no match', () => {
-        expect(resolveLocale('fr', ['en', 'zh-CN'])).toBeUndefined();
-    });
-
-    it('should return undefined for empty available locales', () => {
-        expect(resolveLocale('en', [])).toBeUndefined();
-    });
-
-    it('should handle es → es-ES expansion', () => {
-        expect(resolveLocale('es', ['en', 'es-ES', 'fr'])).toBe('es-ES');
-    });
-});
-
-describe('createMemoryI18n locale fallback', () => {
-    it('should resolve translations via locale fallback (zh → zh-CN)', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('zh-CN', { hello: '你好' });
-        expect(i18n.getTranslations('zh')).toEqual({ hello: '你好' });
-    });
-
-    it('should resolve translations via case-insensitive fallback (zh-cn → zh-CN)', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('zh-CN', { hello: '你好' });
-        expect(i18n.getTranslations('zh-cn')).toEqual({ hello: '你好' });
-    });
-
-    it('should translate via locale fallback (zh → zh-CN)', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('zh-CN', { greeting: '你好世界' });
-        expect(i18n.t('greeting', 'zh')).toBe('你好世界');
-    });
-
-    it('should still fall back to default locale when no locale match at all', () => {
-        const i18n = createMemoryI18n();
-        i18n.loadTranslations('en', { hello: 'Hello' });
-        expect(i18n.t('hello', 'ja')).toBe('Hello');
-    });
-});

package/src/fallbacks/index.ts

@@ -1,26 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { createMemoryCache } from './memory-cache.js';
-import { createMemoryQueue } from './memory-queue.js';
-import { createMemoryJob } from './memory-job.js';
-import { createMemoryI18n } from './memory-i18n.js';
-import { createMemoryMetadata } from './memory-metadata.js';
-
-export { createMemoryCache } from './memory-cache.js';
-export { createMemoryQueue } from './memory-queue.js';
-export { createMemoryJob } from './memory-job.js';
-export { createMemoryI18n, resolveLocale } from './memory-i18n.js';
-export { createMemoryMetadata } from './memory-metadata.js';
-
-/**
- * Map of core-criticality service names to their in-memory fallback factories.
- * Used by ObjectKernel.validateSystemRequirements() to auto-inject fallbacks
- * when no real plugin provides the service.
- */
-export const CORE_FALLBACK_FACTORIES: Record<string, () => Record<string, any>> = {
-  metadata: createMemoryMetadata,
-  cache: createMemoryCache,
-  queue: createMemoryQueue,
-  job:   createMemoryJob,
-  i18n:  createMemoryI18n,
-};