@objectstack/metadata 3.3.0 → 4.0.0

package/src/metadata.test.ts

@@ -1,431 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MetadataManager } from './metadata-manager';
-import { MemoryLoader } from './loaders/memory-loader';
-import type { MetadataLoader } from './loaders/loader-interface';
-
-// Suppress logger output during tests
-vi.mock('@objectstack/core', () => ({
-  createLogger: () => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  }),
-}));
-
-// ---------- MetadataManager ----------
-
-describe('MetadataManager', () => {
-  let manager: MetadataManager;
-  let memoryLoader: MemoryLoader;
-
-  beforeEach(() => {
-    memoryLoader = new MemoryLoader();
-    manager = new MetadataManager({
-      formats: ['json'],
-      loaders: [memoryLoader],
-    });
-  });
-
-  describe('load', () => {
-    it('should return null when item does not exist', async () => {
-      const result = await manager.load('object', 'nonexistent');
-      expect(result).toBeNull();
-    });
-
-    it('should return data from a loader', async () => {
-      await memoryLoader.save('object', 'account', { name: 'account', label: 'Account' });
-      const result = await manager.load('object', 'account');
-      expect(result).toEqual({ name: 'account', label: 'Account' });
-    });
-
-    it('should try loaders in order and return first result', async () => {
-      const loader1 = createMockLoader('first', { name: 'from_first' });
-      const loader2 = createMockLoader('second', { name: 'from_second' });
-
-      const m = new MetadataManager({ formats: ['json'], loaders: [loader1, loader2] });
-      const result = await m.load('object', 'test');
-      expect(result).toEqual({ name: 'from_first' });
-    });
-
-    it('should skip failing loaders and try the next', async () => {
-      const failingLoader = createMockLoader('failing', null, true);
-      const goodLoader = createMockLoader('good', { name: 'ok' });
-
-      const m = new MetadataManager({ formats: ['json'], loaders: [failingLoader, goodLoader] });
-      const result = await m.load('object', 'test');
-      expect(result).toEqual({ name: 'ok' });
-    });
-  });
-
-  describe('loadMany', () => {
-    it('should return empty array when nothing loaded', async () => {
-      const result = await manager.loadMany('object');
-      expect(result).toEqual([]);
-    });
-
-    it('should return all items from a loader', async () => {
-      await memoryLoader.save('object', 'account', { name: 'account' });
-      await memoryLoader.save('object', 'contact', { name: 'contact' });
-
-      const result = await manager.loadMany('object');
-      expect(result).toHaveLength(2);
-    });
-
-    it('should deduplicate items by name across loaders', async () => {
-      const loader1 = createMockLoaderMany('first', [
-        { name: 'account', label: 'Account V1' },
-      ]);
-      const loader2 = createMockLoaderMany('second', [
-        { name: 'account', label: 'Account V2' },
-        { name: 'contact', label: 'Contact' },
-      ]);
-
-      const m = new MetadataManager({ formats: ['json'], loaders: [loader1, loader2] });
-      const result = await m.loadMany<{ name: string; label: string }>('object');
-      expect(result).toHaveLength(2);
-      // First loader wins
-      expect(result.find(r => r.name === 'account')?.label).toBe('Account V1');
-    });
-
-    it('should skip failing loaders in loadMany', async () => {
-      const failingLoader = createMockLoaderMany('failing', [], true);
-      const goodLoader = createMockLoaderMany('good', [{ name: 'ok' }]);
-
-      const m = new MetadataManager({ formats: ['json'], loaders: [failingLoader, goodLoader] });
-      const result = await m.loadMany('object');
-      expect(result).toHaveLength(1);
-    });
-  });
-
-  describe('save', () => {
-    it('should save to a writable loader', async () => {
-      await manager.save('object', 'account', { name: 'account' });
-      const result = await manager.load('object', 'account');
-      expect(result).toEqual({ name: 'account' });
-    });
-
-    it('should throw when no writable loader is available', async () => {
-      const readOnlyLoader: MetadataLoader = {
-        contract: { name: 'readonly', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
-        load: vi.fn().mockResolvedValue({ data: null }),
-        loadMany: vi.fn().mockResolvedValue([]),
-        exists: vi.fn().mockResolvedValue(false),
-        stat: vi.fn().mockResolvedValue(null),
-        list: vi.fn().mockResolvedValue([]),
-        // No save method
-      };
-
-      const m = new MetadataManager({ formats: ['json'], loaders: [readOnlyLoader] });
-      await expect(m.save('object', 'test', {})).rejects.toThrow('No loader available');
-    });
-
-    it('should save to a specific named loader', async () => {
-      await manager.save('object', 'account', { name: 'account' }, { loader: 'memory' } as any);
-      const result = await manager.load('object', 'account');
-      expect(result).toEqual({ name: 'account' });
-    });
-
-    it('should throw when specified loader not found', async () => {
-      await expect(
-        manager.save('object', 'test', {}, { loader: 'nonexistent' } as any)
-      ).rejects.toThrow('Loader not found');
-    });
-  });
-
-  describe('exists', () => {
-    it('should return false for non-existent items', async () => {
-      expect(await manager.exists('object', 'nope')).toBe(false);
-    });
-
-    it('should return true for existing items', async () => {
-      await memoryLoader.save('object', 'account', { name: 'account' });
-      expect(await manager.exists('object', 'account')).toBe(true);
-    });
-  });
-
-  describe('list', () => {
-    it('should return empty array for empty type', async () => {
-      const result = await manager.listNames('object');
-      expect(result).toEqual([]);
-    });
-
-    it('should list all items of a type', async () => {
-      await memoryLoader.save('object', 'account', {});
-      await memoryLoader.save('object', 'contact', {});
-      const result = await manager.listNames('object');
-      expect(result).toHaveLength(2);
-      expect(result).toContain('account');
-      expect(result).toContain('contact');
-    });
-
-    it('should deduplicate across loaders', async () => {
-      const loader1: MetadataLoader = {
-        contract: { name: 'l1', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
-        load: vi.fn().mockResolvedValue({ data: null }),
-        loadMany: vi.fn().mockResolvedValue([]),
-        exists: vi.fn().mockResolvedValue(false),
-        stat: vi.fn().mockResolvedValue(null),
-        list: vi.fn().mockResolvedValue(['account', 'contact']),
-      };
-      const loader2: MetadataLoader = {
-        contract: { name: 'l2', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
-        load: vi.fn().mockResolvedValue({ data: null }),
-        loadMany: vi.fn().mockResolvedValue([]),
-        exists: vi.fn().mockResolvedValue(false),
-        stat: vi.fn().mockResolvedValue(null),
-        list: vi.fn().mockResolvedValue(['account', 'lead']),
-      };
-
-      const m = new MetadataManager({ formats: ['json'], loaders: [loader1, loader2] });
-      const result = await m.listNames('object');
-      expect(result).toHaveLength(3);
-      expect(result).toContain('account');
-      expect(result).toContain('contact');
-      expect(result).toContain('lead');
-    });
-  });
-
-  describe('watch / unwatch', () => {
-    it('should register and invoke watch callbacks', () => {
-      const callback = vi.fn();
-      (manager as any).addWatchCallback('object', callback);
-
-      // Trigger via protected method — cast to access it
-      (manager as any).notifyWatchers('object', {
-        type: 'changed',
-        metadataType: 'object',
-        name: 'account',
-        path: '/fake',
-        timestamp: new Date(),
-      });
-
-      expect(callback).toHaveBeenCalledOnce();
-    });
-
-    it('should unwatch callback', () => {
-      const callback = vi.fn();
-      (manager as any).addWatchCallback('object', callback);
-      (manager as any).removeWatchCallback('object', callback);
-
-      (manager as any).notifyWatchers('object', {
-        type: 'changed',
-        metadataType: 'object',
-        name: 'account',
-        path: '/fake',
-        timestamp: new Date(),
-      });
-
-      expect(callback).not.toHaveBeenCalled();
-    });
-
-    it('should not throw when unwatching non-existent callback', () => {
-      expect(() => (manager as any).removeWatchCallback('object', vi.fn())).not.toThrow();
-    });
-  });
-
-  describe('registerLoader', () => {
-    it('should register a new loader', async () => {
-      const newLoader = new MemoryLoader();
-      await newLoader.save('view', 'dashboard', { name: 'dashboard' });
-
-      manager.registerLoader(newLoader);
-
-      const result = await manager.load('view', 'dashboard');
-      expect(result).toEqual({ name: 'dashboard' });
-    });
-  });
-
-  describe('serializer initialization', () => {
-    it('should initialize with default formats', () => {
-      const m = new MetadataManager({ loaders: [] });
-      // Default formats are typescript, json, yaml
-      expect((m as any).serializers.size).toBe(3);
-    });
-
-    it('should initialize with only requested formats', () => {
-      const m = new MetadataManager({ formats: ['json'], loaders: [] });
-      expect((m as any).serializers.size).toBe(1);
-      expect((m as any).serializers.has('json')).toBe(true);
-    });
-
-    it('should support javascript format', () => {
-      const m = new MetadataManager({ formats: ['javascript'], loaders: [] });
-      expect((m as any).serializers.has('javascript')).toBe(true);
-    });
-  });
-});
-
-// ---------- MemoryLoader ----------
-
-describe('MemoryLoader', () => {
-  let loader: MemoryLoader;
-
-  beforeEach(() => {
-    loader = new MemoryLoader();
-  });
-
-  it('should have correct contract', () => {
-    expect(loader.contract.name).toBe('memory');
-    expect(loader.contract.protocol).toBe('memory:');
-    expect(loader.contract.capabilities.read).toBe(true);
-    expect(loader.contract.capabilities.write).toBe(true);
-  });
-
-  it('should save and load items', async () => {
-    await loader.save('object', 'task', { name: 'task', label: 'Task' });
-    const result = await loader.load('object', 'task');
-    expect(result.data).toEqual({ name: 'task', label: 'Task' });
-    expect(result.source).toBe('memory');
-  });
-
-  it('should return null for missing items', async () => {
-    const result = await loader.load('object', 'missing');
-    expect(result.data).toBeNull();
-  });
-
-  it('should check existence', async () => {
-    expect(await loader.exists('object', 'task')).toBe(false);
-    await loader.save('object', 'task', {});
-    expect(await loader.exists('object', 'task')).toBe(true);
-  });
-
-  it('should list items', async () => {
-    await loader.save('object', 'a', {});
-    await loader.save('object', 'b', {});
-    const items = await loader.list('object');
-    expect(items).toEqual(['a', 'b']);
-  });
-
-  it('should return empty list for unknown types', async () => {
-    expect(await loader.list('unknown')).toEqual([]);
-  });
-
-  it('should loadMany items', async () => {
-    await loader.save('object', 'a', { name: 'a' });
-    await loader.save('object', 'b', { name: 'b' });
-    const items = await loader.loadMany('object');
-    expect(items).toHaveLength(2);
-  });
-
-  it('should return stats for existing items', async () => {
-    await loader.save('object', 'task', {});
-    const stats = await loader.stat('object', 'task');
-    expect(stats).not.toBeNull();
-    expect(stats!.format).toBe('json');
-  });
-
-  it('should return null stats for missing items', async () => {
-    const stats = await loader.stat('object', 'missing');
-    expect(stats).toBeNull();
-  });
-
-  it('should return save result with path', async () => {
-    const result = await loader.save('object', 'task', {});
-    expect(result.success).toBe(true);
-    expect(result.path).toBe('memory://object/task');
-  });
-});
-
-// ---------- MetadataPlugin ----------
-
-describe('MetadataPlugin', () => {
-  // Plugin creates NodeMetadataManager which depends on node:path and chokidar.
-  // We mock NodeMetadataManager to avoid filesystem side effects.
-  vi.mock('./node-metadata-manager', () => {
-    const MockNodeMetadataManager = class {
-      loadMany = vi.fn().mockResolvedValue([]);
-      registerLoader = vi.fn();
-      stopWatching = vi.fn();
-      setTypeRegistry = vi.fn();
-      register = vi.fn();
-    };
-    return { NodeMetadataManager: MockNodeMetadataManager };
-  });
-
-  // Mock the spec kernel import
-  vi.mock('@objectstack/spec/kernel', () => ({
-    DEFAULT_METADATA_TYPE_REGISTRY: [
-      { type: 'object', label: 'Object', filePatterns: ['**/*.object.ts'], supportsOverlay: true, allowRuntimeCreate: false, supportsVersioning: true, loadOrder: 10, domain: 'data' },
-      { type: 'view', label: 'View', filePatterns: ['**/*.view.ts'], supportsOverlay: true, allowRuntimeCreate: true, supportsVersioning: false, loadOrder: 50, domain: 'ui' },
-    ],
-  }));
-
-  it('should have correct plugin metadata', async () => {
-    const { MetadataPlugin } = await import('./plugin.js');
-    const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
-    expect(plugin.name).toBe('com.objectstack.metadata');
-    expect(plugin.version).toBe('1.0.0');
-    expect(plugin.type).toBe('standard');
-  });
-
-  it('should call init and register metadata service', async () => {
-    const { MetadataPlugin } = await import('./plugin.js');
-    const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
-
-    const ctx = createMockPluginContext();
-    await plugin.init(ctx);
-
-    expect(ctx.registerService).toHaveBeenCalledWith('metadata', expect.anything());
-  });
-
-  it('should call start and attempt to load metadata types', async () => {
-    const { MetadataPlugin } = await import('./plugin.js');
-    const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
-
-    const ctx = createMockPluginContext();
-    await plugin.init(ctx);
-    await plugin.start(ctx);
-
-    // start should call logger.info at least once
-    expect(ctx.logger.info).toHaveBeenCalled();
-  });
-});
-
-// ---------- Helpers ----------
-
-function createMockLoader(name: string, data: any, shouldFail = false): MetadataLoader {
-  return {
-    contract: { name, protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
-    load: shouldFail
-      ? vi.fn().mockRejectedValue(new Error('loader failed'))
-      : vi.fn().mockResolvedValue({ data }),
-    loadMany: vi.fn().mockResolvedValue([]),
-    exists: vi.fn().mockResolvedValue(false),
-    stat: vi.fn().mockResolvedValue(null),
-    list: vi.fn().mockResolvedValue([]),
-  };
-}
-
-function createMockLoaderMany(name: string, items: any[], shouldFail = false): MetadataLoader {
-  return {
-    contract: { name, protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
-    load: vi.fn().mockResolvedValue({ data: null }),
-    loadMany: shouldFail
-      ? vi.fn().mockRejectedValue(new Error('loader failed'))
-      : vi.fn().mockResolvedValue(items),
-    exists: vi.fn().mockResolvedValue(false),
-    stat: vi.fn().mockResolvedValue(null),
-    list: vi.fn().mockResolvedValue([]),
-  };
-}
-
-function createMockPluginContext() {
-  return {
-    registerService: vi.fn(),
-    replaceService: vi.fn(),
-    getService: vi.fn().mockReturnValue(null),
-    getServices: vi.fn().mockReturnValue(new Map()),
-    hook: vi.fn(),
-    trigger: vi.fn(),
-    logger: {
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-      debug: vi.fn(),
-    },
-    getKernel: vi.fn(),
-  };
-}

package/src/migration/executor.ts

@@ -1,54 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { System } from '@objectstack/spec';
-import { ISchemaDriver } from '@objectstack/spec/contracts';
-
-export class MigrationExecutor {
-  constructor(private driver: ISchemaDriver) {}
-
-  async executeChangeSet(changeSet: System.ChangeSet): Promise<void> {
-    console.log(`Executing ChangeSet: ${changeSet.name} (${changeSet.id})`);
-    
-    for (const op of changeSet.operations) {
-      try {
-        await this.executeOperation(op);
-      } catch (e) {
-        console.error(`Failed to execute operation ${op.type}:`, e);
-        throw e;
-      }
-    }
-  }
-
-  private async executeOperation(op: System.MigrationOperation): Promise<void> {
-    switch (op.type) {
-      case 'create_object':
-        console.log(`  > Create Object: ${op.object.name}`);
-        await this.driver.createCollection(op.object.name, op.object);
-        break;
-      case 'add_field':
-        console.log(`  > Add Field: ${op.objectName}.${op.fieldName}`);
-        await this.driver.addColumn(op.objectName, op.fieldName, op.field);
-        break;
-      case 'remove_field':
-        console.log(`  > Remove Field: ${op.objectName}.${op.fieldName}`);
-        await this.driver.dropColumn(op.objectName, op.fieldName);
-        break;
-      case 'delete_object':
-        console.log(`  > Delete Object: ${op.objectName}`);
-        await this.driver.dropCollection(op.objectName);
-        break;
-      case 'execute_sql':
-        console.log(`  > Execute SQL`);
-        await this.driver.executeRaw(op.sql);
-        break;
-      case 'modify_field':
-        console.warn(`  ! Modify Field: ${op.objectName}.${op.fieldName} (Not fully implemented)`);
-        break;
-      case 'rename_object':
-        console.warn(`  ! Rename Object: ${op.oldName} -> ${op.newName} (Not fully implemented)`);
-        break;
-      default:
-        throw new Error(`Unknown operation type`);
-    }
-  }
-}

package/src/migration/index.ts

@@ -1,3 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-export * from './executor.js';

package/src/node-metadata-manager.ts

@@ -1,126 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-/**
- * Node Metadata Manager
- * 
- * Extends MetadataManager with Filesystem capabilities (Watching, default loader)
- */
-
-import * as path from 'node:path';
-import { watch as chokidarWatch, type FSWatcher } from 'chokidar';
-import type {
-  MetadataWatchEvent,
-} from '@objectstack/spec/system';
-import { FilesystemLoader } from './loaders/filesystem-loader.js';
-import { MetadataManager, type MetadataManagerOptions } from './metadata-manager.js';
-
-/**
- * Node metadata manager class
- */
-export class NodeMetadataManager extends MetadataManager {
-  private watcher?: FSWatcher;
-
-  constructor(config: MetadataManagerOptions) {
-    super(config);
-
-    // Initialize Default Filesystem Loader if no loaders provided
-    // This logic replaces the removed logic from base class
-    if (!config.loaders || config.loaders.length === 0) {
-      const rootDir = config.rootDir || process.cwd();
-      this.registerLoader(new FilesystemLoader(rootDir, this.serializers, this.logger));
-    }
-
-    // Start watching if enabled
-    if (config.watch) {
-      this.startWatching();
-    }
-  }
-
-  /**
-   * Stop all watching
-   */
-  async stopWatching(): Promise<void> {
-    if (this.watcher) {
-      await this.watcher.close();
-      this.watcher = undefined;
-    }
-    // Call base cleanup if any
-  }
-
-  /**
-   * Start watching for file changes
-   */
-  private startWatching(): void {
-    const rootDir = this.config.rootDir || process.cwd();
-    const { ignored = ['**/node_modules/**', '**/*.test.*'], persistent = true } =
-      this.config.watchOptions || {};
-
-    this.watcher = chokidarWatch(rootDir, {
-      ignored,
-      persistent,
-      ignoreInitial: true,
-    });
-
-    this.watcher.on('add', async (filePath) => {
-      await this.handleFileEvent('added', filePath);
-    });
-
-    this.watcher.on('change', async (filePath) => {
-      await this.handleFileEvent('changed', filePath);
-    });
-
-    this.watcher.on('unlink', async (filePath) => {
-      await this.handleFileEvent('deleted', filePath);
-    });
-
-    this.logger.info('File watcher started', { rootDir });
-  }
-
-  /**
-   * Handle file change events
-   */
-  private async handleFileEvent(
-    eventType: 'added' | 'changed' | 'deleted',
-    filePath: string
-  ): Promise<void> {
-    const rootDir = this.config.rootDir || process.cwd();
-    const relativePath = path.relative(rootDir, filePath);
-    const parts = relativePath.split(path.sep);
-
-    if (parts.length < 2) {
-      return; // Not a metadata file
-    }
-
-    const type = parts[0];
-    const fileName = parts[parts.length - 1];
-    const name = path.basename(fileName, path.extname(fileName));
-
-    // We can't access private watchCallbacks from parent.
-    // We need a protected method to trigger watch event or access it.
-    // OPTION: Add a method `triggerWatchEvent` to MetadataManager
-    
-    let data: any = undefined;
-    if (eventType !== 'deleted') {
-      try {
-        data = await this.load(type, name, { useCache: false });
-      } catch (error) {
-        this.logger.error('Failed to load changed file', undefined, {
-          filePath,
-          error: error instanceof Error ? error.message : String(error),
-        });
-        return;
-      }
-    }
-
-    const event: MetadataWatchEvent = {
-      type: eventType,
-      metadataType: type,
-      name,
-      path: filePath,
-      data,
-      timestamp: new Date().toISOString(),
-    };
-
-    this.notifyWatchers(type, event);
-  }
-}

package/src/node.ts

@@ -1,11 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-/**
- * Node.js specific exports for @objectstack/metadata
- */
-
-export * from './index.js';
-export { NodeMetadataManager } from './node-metadata-manager.js';
-export { FilesystemLoader } from './loaders/filesystem-loader.js';
-export { DatabaseLoader, type DatabaseLoaderOptions } from './loaders/database-loader.js';
-export { MetadataPlugin } from './plugin.js';