@objectstack/metadata 1.0.2 → 1.0.5

package/dist/loaders/loader-interface.js

@@ -1,6 +0,0 @@
-/**
- * Metadata Loader Interface
- *
- * Defines the contract for loading metadata from various sources
- */
-export {};

package/dist/loaders/memory-loader.d.ts

@@ -1,19 +0,0 @@
-/**
- * Memory Metadata Loader
- *
- * Stores metadata in memory only. Changes are lost when process restarts.
- * Useful for testing, temporary overrides, or "dirty" edits.
- */
-import type { MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataLoaderContract, MetadataSaveOptions, MetadataSaveResult } from '@objectstack/spec/system';
-import type { MetadataLoader } from './loader-interface.js';
-export declare class MemoryLoader implements MetadataLoader {
-    readonly contract: MetadataLoaderContract;
-    private storage;
-    load(type: string, name: string, _options?: MetadataLoadOptions): Promise<MetadataLoadResult>;
-    loadMany<T = any>(type: string, _options?: MetadataLoadOptions): Promise<T[]>;
-    exists(type: string, name: string): Promise<boolean>;
-    stat(type: string, name: string): Promise<MetadataStats | null>;
-    list(type: string): Promise<string[]>;
-    save(type: string, name: string, data: any, _options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
-}
-//# sourceMappingURL=memory-loader.d.ts.map

package/dist/loaders/memory-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory-loader.d.ts","sourceRoot":"","sources":["../../src/loaders/memory-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,YAAa,YAAW,cAAc;IACjD,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CASvC;IAGF,OAAO,CAAC,OAAO,CAAuC;IAEhD,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IAgBxB,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,CAAC,EAAE,CAAC;IAMT,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIpD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAW/D,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAMrC,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;CAa/B"}

package/dist/loaders/memory-loader.js

@@ -1,71 +0,0 @@
-/**
- * Memory Metadata Loader
- *
- * Stores metadata in memory only. Changes are lost when process restarts.
- * Useful for testing, temporary overrides, or "dirty" edits.
- */
-export class MemoryLoader {
-    constructor() {
-        this.contract = {
-            name: 'memory',
-            protocol: 'memory',
-            capabilities: {
-                read: true,
-                write: true,
-                watch: false,
-                list: true,
-            },
-        };
-        // Storage: Type -> Name -> Data
-        this.storage = new Map();
-    }
-    async load(type, name, _options) {
-        const typeStore = this.storage.get(type);
-        const data = typeStore?.get(name);
-        if (data) {
-            return {
-                data,
-                source: 'memory',
-                format: 'json',
-                loadTime: 0,
-            };
-        }
-        return { data: null };
-    }
-    async loadMany(type, _options) {
-        const typeStore = this.storage.get(type);
-        if (!typeStore)
-            return [];
-        return Array.from(typeStore.values());
-    }
-    async exists(type, name) {
-        return this.storage.get(type)?.has(name) ?? false;
-    }
-    async stat(type, name) {
-        if (await this.exists(type, name)) {
-            return {
-                size: 0, // In-memory
-                mtime: new Date(),
-                format: 'json',
-            };
-        }
-        return null;
-    }
-    async list(type) {
-        const typeStore = this.storage.get(type);
-        if (!typeStore)
-            return [];
-        return Array.from(typeStore.keys());
-    }
-    async save(type, name, data, _options) {
-        if (!this.storage.has(type)) {
-            this.storage.set(type, new Map());
-        }
-        this.storage.get(type).set(name, data);
-        return {
-            success: true,
-            path: `memory://${type}/${name}`,
-            saveTime: 0,
-        };
-    }
-}

package/dist/loaders/remote-loader.d.ts

@@ -1,22 +0,0 @@
-/**
- * Remote Metadata Loader
- *
- * Loads metadata from an HTTP API.
- * This loader is stateless and delegates storage to the remote server.
- */
-import type { MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataLoaderContract, MetadataSaveOptions, MetadataSaveResult } from '@objectstack/spec/system';
-import type { MetadataLoader } from './loader-interface.js';
-export declare class RemoteLoader implements MetadataLoader {
-    private baseUrl;
-    private authToken?;
-    readonly contract: MetadataLoaderContract;
-    constructor(baseUrl: string, authToken?: string | undefined);
-    private get headers();
-    load(type: string, name: string, _options?: MetadataLoadOptions): Promise<MetadataLoadResult>;
-    loadMany<T = any>(type: string, _options?: MetadataLoadOptions): Promise<T[]>;
-    exists(type: string, name: string): Promise<boolean>;
-    stat(type: string, name: string): Promise<MetadataStats | null>;
-    list(type: string): Promise<string[]>;
-    save(type: string, name: string, data: any, _options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
-}
-//# sourceMappingURL=remote-loader.d.ts.map

package/dist/loaders/remote-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-loader.d.ts","sourceRoot":"","sources":["../../src/loaders/remote-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,YAAa,YAAW,cAAc;IAYrC,OAAO,CAAC,OAAO;IAAU,OAAO,CAAC,SAAS,CAAC;IAXvD,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CASvC;gBAEkB,OAAO,EAAE,MAAM,EAAU,SAAS,CAAC,EAAE,MAAM,YAAA;IAE/D,OAAO,KAAK,OAAO,GAKlB;IAEK,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IA4BxB,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,CAAC,EAAE,CAAC;IAaT,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQpD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAgB/D,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKrC,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;CAiB/B"}

package/dist/loaders/remote-loader.js

@@ -1,103 +0,0 @@
-/**
- * Remote Metadata Loader
- *
- * Loads metadata from an HTTP API.
- * This loader is stateless and delegates storage to the remote server.
- */
-export class RemoteLoader {
-    constructor(baseUrl, authToken) {
-        this.baseUrl = baseUrl;
-        this.authToken = authToken;
-        this.contract = {
-            name: 'remote',
-            protocol: 'http',
-            capabilities: {
-                read: true,
-                write: true,
-                watch: false, // Could implement SSE/WebSocket in future
-                list: true,
-            },
-        };
-    }
-    get headers() {
-        return {
-            'Content-Type': 'application/json',
-            ...(this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}),
-        };
-    }
-    async load(type, name, _options) {
-        try {
-            const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
-                method: 'GET',
-                headers: this.headers,
-            });
-            if (response.status === 404) {
-                return { data: null };
-            }
-            if (!response.ok) {
-                throw new Error(`Remote load failed: ${response.statusText}`);
-            }
-            const data = await response.json();
-            return {
-                data,
-                source: this.baseUrl,
-                format: 'json',
-                loadTime: 0,
-            };
-        }
-        catch (error) {
-            console.error(`RemoteLoader error loading ${type}/${name}`, error);
-            throw error;
-        }
-    }
-    async loadMany(type, _options) {
-        const response = await fetch(`${this.baseUrl}/${type}`, {
-            method: 'GET',
-            headers: this.headers,
-        });
-        if (!response.ok) {
-            return [];
-        }
-        return (await response.json());
-    }
-    async exists(type, name) {
-        const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
-            method: 'HEAD',
-            headers: this.headers,
-        });
-        return response.ok;
-    }
-    async stat(type, name) {
-        // Basic implementation using HEAD
-        const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
-            method: 'HEAD',
-            headers: this.headers,
-        });
-        if (!response.ok)
-            return null;
-        return {
-            size: Number(response.headers.get('content-length') || 0),
-            mtime: new Date(response.headers.get('last-modified') || Date.now()),
-            format: 'json',
-        };
-    }
-    async list(type) {
-        const items = await this.loadMany(type);
-        return items.map(i => i.name);
-    }
-    async save(type, name, data, _options) {
-        const response = await fetch(`${this.baseUrl}/${type}/${name}`, {
-            method: 'PUT',
-            headers: this.headers,
-            body: JSON.stringify(data),
-        });
-        if (!response.ok) {
-            throw new Error(`Remote save failed: ${response.statusText}`);
-        }
-        return {
-            success: true,
-            path: `${this.baseUrl}/${type}/${name}`,
-            saveTime: 0,
-        };
-    }
-}

package/dist/metadata-manager.d.ts

@@ -1,71 +0,0 @@
-/**
- * Metadata Manager
- *
- * Main orchestrator for metadata loading, saving, and persistence.
- * Browser-compatible (Pure).
- */
-import type { MetadataManagerConfig, MetadataLoadOptions, MetadataSaveOptions, MetadataSaveResult, MetadataWatchEvent, MetadataFormat } from '@objectstack/spec/system';
-import { type Logger } from '@objectstack/core';
-import type { MetadataSerializer } from './serializers/serializer-interface.js';
-import type { MetadataLoader } from './loaders/loader-interface.js';
-/**
- * Watch callback function
- */
-export type WatchCallback = (event: MetadataWatchEvent) => void | Promise<void>;
-export interface MetadataManagerOptions extends MetadataManagerConfig {
-    loaders?: MetadataLoader[];
-}
-/**
- * Main metadata manager class
- */
-export declare class MetadataManager {
-    private loaders;
-    protected serializers: Map<MetadataFormat, MetadataSerializer>;
-    protected logger: Logger;
-    protected watchCallbacks: Map<string, Set<WatchCallback>>;
-    protected config: MetadataManagerOptions;
-    constructor(config: MetadataManagerOptions);
-    /**
-     * Register a new metadata loader (data source)
-     */
-    registerLoader(loader: MetadataLoader): void;
-    /**
-     * Load a single metadata item
-     * Iterates through registered loaders until found
-     */
-    load<T = any>(type: string, name: string, options?: MetadataLoadOptions): Promise<T | null>;
-    /**
-     * Load multiple metadata items
-     * Aggregates results from all loaders
-     */
-    loadMany<T = any>(type: string, options?: MetadataLoadOptions): Promise<T[]>;
-    /**
-     * Save metadata to disk
-     */
-    /**
-     * Save metadata item
-     */
-    save<T = any>(type: string, name: string, data: T, options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
-    /**
-     * Check if metadata item exists
-     */
-    exists(type: string, name: string): Promise<boolean>;
-    /**
-     * List all items of a type
-     */
-    list(type: string): Promise<string[]>;
-    /**
-     * Watch for metadata changes
-     */
-    watch(type: string, callback: WatchCallback): void;
-    /**
-     * Unwatch metadata changes
-     */
-    unwatch(type: string, callback: WatchCallback): void;
-    /**
-     * Stop all watching
-     */
-    stopWatching(): Promise<void>;
-    protected notifyWatchers(type: string, event: MetadataWatchEvent): void;
-}
-//# sourceMappingURL=metadata-manager.d.ts.map

package/dist/metadata-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadata-manager.d.ts","sourceRoot":"","sources":["../src/metadata-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhF,MAAM,WAAW,sBAAuB,SAAQ,qBAAqB;IACnE,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAA0C;IAEzD,SAAS,CAAC,WAAW,EAAE,GAAG,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;IAC/D,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,cAAc,kCAAyC;IACjE,SAAS,CAAC,MAAM,EAAE,sBAAsB,CAAC;gBAE7B,MAAM,EAAE,sBAAsB;IA4B1C;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,cAAc;IAKrC;;;OAGG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAgBpB;;;OAGG;IACG,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC;IAiBf;;OAEG;IACH;;OAEG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IA0D9B;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS1D;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAS3C;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAOlD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAUpD;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB;CAejE"}

package/dist/metadata-manager.js

@@ -1,211 +0,0 @@
-/**
- * Metadata Manager
- *
- * Main orchestrator for metadata loading, saving, and persistence.
- * Browser-compatible (Pure).
- */
-import { createLogger } from '@objectstack/core';
-import { JSONSerializer } from './serializers/json-serializer.js';
-import { YAMLSerializer } from './serializers/yaml-serializer.js';
-import { TypeScriptSerializer } from './serializers/typescript-serializer.js';
-/**
- * Main metadata manager class
- */
-export class MetadataManager {
-    constructor(config) {
-        this.loaders = new Map();
-        this.watchCallbacks = new Map();
-        this.config = config;
-        this.logger = createLogger({ level: 'info', format: 'pretty' });
-        // Initialize serializers
-        this.serializers = new Map();
-        const formats = config.formats || ['typescript', 'json', 'yaml'];
-        if (formats.includes('json')) {
-            this.serializers.set('json', new JSONSerializer());
-        }
-        if (formats.includes('yaml')) {
-            this.serializers.set('yaml', new YAMLSerializer());
-        }
-        if (formats.includes('typescript')) {
-            this.serializers.set('typescript', new TypeScriptSerializer('typescript'));
-        }
-        if (formats.includes('javascript')) {
-            this.serializers.set('javascript', new TypeScriptSerializer('javascript'));
-        }
-        // Initialize Loaders
-        if (config.loaders && config.loaders.length > 0) {
-            config.loaders.forEach(loader => this.registerLoader(loader));
-        }
-        // Note: No default loader in base class. Subclasses (NodeMetadataManager) or caller must provide one.
-    }
-    /**
-     * Register a new metadata loader (data source)
-     */
-    registerLoader(loader) {
-        this.loaders.set(loader.contract.name, loader);
-        this.logger.info(`Registered metadata loader: ${loader.contract.name} (${loader.contract.protocol})`);
-    }
-    /**
-     * Load a single metadata item
-     * Iterates through registered loaders until found
-     */
-    async load(type, name, options) {
-        // Priority: Database > Filesystem (Implementation-dependent)
-        // For now, we just iterate.
-        for (const loader of this.loaders.values()) {
-            try {
-                const result = await loader.load(type, name, options);
-                if (result.data) {
-                    return result.data;
-                }
-            }
-            catch (e) {
-                this.logger.warn(`Loader ${loader.contract.name} failed to load ${type}:${name}`, { error: e });
-            }
-        }
-        return null;
-    }
-    /**
-     * Load multiple metadata items
-     * Aggregates results from all loaders
-     */
-    async loadMany(type, options) {
-        const results = [];
-        for (const loader of this.loaders.values()) {
-            try {
-                const items = await loader.loadMany(type, options);
-                for (const item of items) {
-                    // TODO: Deduplicate based on 'name' if property exists
-                    results.push(item);
-                }
-            }
-            catch (e) {
-                this.logger.warn(`Loader ${loader.contract.name} failed to loadMany ${type}`, { error: e });
-            }
-        }
-        return results;
-    }
-    /**
-     * Save metadata to disk
-     */
-    /**
-     * Save metadata item
-     */
-    async save(type, name, data, options) {
-        const targetLoader = options?.loader;
-        // Find suitable loader
-        let loader;
-        if (targetLoader) {
-            loader = this.loaders.get(targetLoader);
-            if (!loader) {
-                throw new Error(`Loader not found: ${targetLoader}`);
-            }
-        }
-        else {
-            // 1. Try to find existing writable loader containing this item (Update existing)
-            for (const l of this.loaders.values()) {
-                // Skip if loader is strictly read-only
-                if (!l.save)
-                    continue;
-                try {
-                    if (await l.exists(type, name)) {
-                        loader = l;
-                        this.logger.info(`Updating existing metadata in loader: ${l.contract.name}`);
-                        break;
-                    }
-                }
-                catch (e) {
-                    // Ignore existence check errors (e.g. network down)
-                }
-            }
-            // 2. Default to 'filesystem' if available (Create new)
-            if (!loader) {
-                const fsLoader = this.loaders.get('filesystem');
-                if (fsLoader && fsLoader.save) {
-                    loader = fsLoader;
-                }
-            }
-            // 3. Fallback to any writable loader
-            if (!loader) {
-                for (const l of this.loaders.values()) {
-                    if (l.save) {
-                        loader = l;
-                        break;
-                    }
-                }
-            }
-        }
-        if (!loader) {
-            throw new Error(`No loader available for saving type: ${type}`);
-        }
-        if (!loader.save) {
-            throw new Error(`Loader '${loader.contract?.name}' does not support saving`);
-        }
-        return loader.save(type, name, data, options);
-    }
-    /**
-     * Check if metadata item exists
-     */
-    async exists(type, name) {
-        for (const loader of this.loaders.values()) {
-            if (await loader.exists(type, name)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * List all items of a type
-     */
-    async list(type) {
-        const items = new Set();
-        for (const loader of this.loaders.values()) {
-            const result = await loader.list(type);
-            result.forEach(item => items.add(item));
-        }
-        return Array.from(items);
-    }
-    /**
-     * Watch for metadata changes
-     */
-    watch(type, callback) {
-        if (!this.watchCallbacks.has(type)) {
-            this.watchCallbacks.set(type, new Set());
-        }
-        this.watchCallbacks.get(type).add(callback);
-    }
-    /**
-     * Unwatch metadata changes
-     */
-    unwatch(type, callback) {
-        const callbacks = this.watchCallbacks.get(type);
-        if (callbacks) {
-            callbacks.delete(callback);
-            if (callbacks.size === 0) {
-                this.watchCallbacks.delete(type);
-            }
-        }
-    }
-    /**
-     * Stop all watching
-     */
-    async stopWatching() {
-        // Override in subclass
-    }
-    notifyWatchers(type, event) {
-        const callbacks = this.watchCallbacks.get(type);
-        if (!callbacks)
-            return;
-        for (const callback of callbacks) {
-            try {
-                void callback(event);
-            }
-            catch (error) {
-                this.logger.error('Watch callback error', undefined, {
-                    type,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-    }
-}

package/dist/migration/executor.d.ts

@@ -1,9 +0,0 @@
-import { System } from '@objectstack/spec';
-import { ISchemaDriver } from '@objectstack/spec/contracts';
-export declare class MigrationExecutor {
-    private driver;
-    constructor(driver: ISchemaDriver);
-    executeChangeSet(changeSet: System.ChangeSet): Promise<void>;
-    private executeOperation;
-}
-//# sourceMappingURL=executor.d.ts.map

package/dist/migration/executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/migration/executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,qBAAa,iBAAiB;IAChB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEnC,gBAAgB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;YAapD,gBAAgB;CAgC/B"}

package/dist/migration/executor.js

@@ -1,49 +0,0 @@
-export class MigrationExecutor {
-    constructor(driver) {
-        this.driver = driver;
-    }
-    async executeChangeSet(changeSet) {
-        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;
-            }
-        }
-    }
-    async executeOperation(op) {
-        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/dist/migration/index.d.ts

@@ -1,2 +0,0 @@
-export * from './executor.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/migration/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migration/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/migration/index.js

@@ -1 +0,0 @@
-export * from './executor.js';

package/dist/node-metadata-manager.d.ts

@@ -1,26 +0,0 @@
-/**
- * Node Metadata Manager
- *
- * Extends MetadataManager with Filesystem capabilities (Watching, default loader)
- */
-import { MetadataManager, type MetadataManagerOptions } from './metadata-manager.js';
-/**
- * Node metadata manager class
- */
-export declare class NodeMetadataManager extends MetadataManager {
-    private watcher?;
-    constructor(config: MetadataManagerOptions);
-    /**
-     * Stop all watching
-     */
-    stopWatching(): Promise<void>;
-    /**
-     * Start watching for file changes
-     */
-    private startWatching;
-    /**
-     * Handle file change events
-     */
-    private handleFileEvent;
-}
-//# sourceMappingURL=node-metadata-manager.d.ts.map

package/dist/node-metadata-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-metadata-manager.d.ts","sourceRoot":"","sources":["../src/node-metadata-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAErF;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,eAAe;IACtD,OAAO,CAAC,OAAO,CAAC,CAAY;gBAEhB,MAAM,EAAE,sBAAsB;IAgB1C;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAQnC;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;YACW,eAAe;CA4C9B"}