@objectstack/metadata 0.7.1

package/dist/loaders/filesystem-loader.js

@@ -0,0 +1,260 @@
+/**
+ * Filesystem Metadata Loader
+ *
+ * Loads metadata from the filesystem using glob patterns
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { glob } from 'glob';
+import { createHash } from 'node:crypto';
+export class FilesystemLoader {
+    constructor(rootDir, serializers, logger) {
+        this.rootDir = rootDir;
+        this.serializers = serializers;
+        this.logger = logger;
+        this.contract = {
+            name: 'filesystem',
+            supportedFormats: ['json', 'yaml', 'typescript', 'javascript'],
+            supportsWatch: true,
+            supportsWrite: true,
+            supportsCache: true,
+        };
+        this.cache = new Map();
+    }
+    async load(type, name, options) {
+        const startTime = Date.now();
+        const { validate: _validate = true, useCache = true, ifNoneMatch } = options || {};
+        try {
+            // Find the file
+            const filePath = await this.findFile(type, name);
+            if (!filePath) {
+                return {
+                    data: null,
+                    fromCache: false,
+                    notModified: false,
+                    loadTime: Date.now() - startTime,
+                };
+            }
+            // Get stats
+            const stats = await this.stat(type, name);
+            if (!stats) {
+                return {
+                    data: null,
+                    fromCache: false,
+                    notModified: false,
+                    loadTime: Date.now() - startTime,
+                };
+            }
+            // Check cache
+            if (useCache && ifNoneMatch && stats.etag === ifNoneMatch) {
+                return {
+                    data: null,
+                    fromCache: true,
+                    notModified: true,
+                    etag: stats.etag,
+                    stats,
+                    loadTime: Date.now() - startTime,
+                };
+            }
+            // Check memory cache
+            const cacheKey = `${type}:${name}`;
+            if (useCache && this.cache.has(cacheKey)) {
+                const cached = this.cache.get(cacheKey);
+                if (cached.etag === stats.etag) {
+                    return {
+                        data: cached.data,
+                        fromCache: true,
+                        notModified: false,
+                        etag: stats.etag,
+                        stats,
+                        loadTime: Date.now() - startTime,
+                    };
+                }
+            }
+            // Load and deserialize
+            const content = await fs.readFile(filePath, 'utf-8');
+            const serializer = this.getSerializer(stats.format);
+            if (!serializer) {
+                throw new Error(`No serializer found for format: ${stats.format}`);
+            }
+            const data = serializer.deserialize(content);
+            // Update cache
+            if (useCache) {
+                this.cache.set(cacheKey, {
+                    data,
+                    etag: stats.etag,
+                    timestamp: Date.now(),
+                });
+            }
+            return {
+                data,
+                fromCache: false,
+                notModified: false,
+                etag: stats.etag,
+                stats,
+                loadTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            this.logger?.error('Failed to load metadata', undefined, {
+                type,
+                name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async loadMany(type, options) {
+        const { patterns = ['**/*'], recursive: _recursive = true, limit } = options || {};
+        const typeDir = path.join(this.rootDir, type);
+        const items = [];
+        try {
+            // Build glob patterns
+            const globPatterns = patterns.map(pattern => path.join(typeDir, pattern));
+            for (const pattern of globPatterns) {
+                const files = await glob(pattern, {
+                    ignore: ['**/node_modules/**', '**/*.test.*', '**/*.spec.*'],
+                    nodir: true,
+                });
+                for (const file of files) {
+                    if (limit && items.length >= limit) {
+                        break;
+                    }
+                    try {
+                        const content = await fs.readFile(file, 'utf-8');
+                        const format = this.detectFormat(file);
+                        const serializer = this.getSerializer(format);
+                        if (serializer) {
+                            const data = serializer.deserialize(content);
+                            items.push(data);
+                        }
+                    }
+                    catch (error) {
+                        this.logger?.warn('Failed to load file', {
+                            file,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+                if (limit && items.length >= limit) {
+                    break;
+                }
+            }
+            return items;
+        }
+        catch (error) {
+            this.logger?.error('Failed to load many', undefined, {
+                type,
+                patterns,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async exists(type, name) {
+        const filePath = await this.findFile(type, name);
+        return filePath !== null;
+    }
+    async stat(type, name) {
+        const filePath = await this.findFile(type, name);
+        if (!filePath) {
+            return null;
+        }
+        try {
+            const stats = await fs.stat(filePath);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const etag = this.generateETag(content);
+            const format = this.detectFormat(filePath);
+            return {
+                size: stats.size,
+                modifiedAt: stats.mtime,
+                etag,
+                format,
+                path: filePath,
+            };
+        }
+        catch (error) {
+            this.logger?.error('Failed to stat file', undefined, {
+                type,
+                name,
+                filePath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    async list(type) {
+        const typeDir = path.join(this.rootDir, type);
+        try {
+            const files = await glob('**/*', {
+                cwd: typeDir,
+                ignore: ['**/node_modules/**', '**/*.test.*', '**/*.spec.*'],
+                nodir: true,
+            });
+            return files.map(file => {
+                const ext = path.extname(file);
+                const basename = path.basename(file, ext);
+                return basename;
+            });
+        }
+        catch (error) {
+            this.logger?.error('Failed to list', undefined, {
+                type,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Find file for a given type and name
+     */
+    async findFile(type, name) {
+        const typeDir = path.join(this.rootDir, type);
+        const extensions = ['.json', '.yaml', '.yml', '.ts', '.js'];
+        for (const ext of extensions) {
+            const filePath = path.join(typeDir, `${name}${ext}`);
+            try {
+                await fs.access(filePath);
+                return filePath;
+            }
+            catch {
+                // File doesn't exist, try next extension
+            }
+        }
+        return null;
+    }
+    /**
+     * Detect format from file extension
+     */
+    detectFormat(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        switch (ext) {
+            case '.json':
+                return 'json';
+            case '.yaml':
+            case '.yml':
+                return 'yaml';
+            case '.ts':
+                return 'typescript';
+            case '.js':
+                return 'javascript';
+            default:
+                return 'json'; // Default to JSON
+        }
+    }
+    /**
+     * Get serializer for format
+     */
+    getSerializer(format) {
+        return this.serializers.get(format);
+    }
+    /**
+     * Generate ETag for content
+     * Uses SHA-256 hash truncated to 32 characters for reasonable collision resistance
+     * while keeping ETag headers compact (full 64-char hash is overkill for this use case)
+     */
+    generateETag(content) {
+        const hash = createHash('sha256').update(content).digest('hex').substring(0, 32);
+        return `"${hash}"`;
+    }
+}

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

@@ -0,0 +1,52 @@
+/**
+ * Metadata Loader Interface
+ *
+ * Defines the contract for loading metadata from various sources
+ */
+import type { MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataLoaderContract } from '@objectstack/spec/system';
+/**
+ * Abstract interface for metadata loaders
+ * Implementations can load from filesystem, HTTP, S3, databases, etc.
+ */
+export interface MetadataLoader {
+    /**
+     * Loader contract information
+     */
+    readonly contract: MetadataLoaderContract;
+    /**
+     * Load a single metadata item
+     * @param type The metadata type (e.g., 'object', 'view', 'app')
+     * @param name The item name/identifier
+     * @param options Load options
+     * @returns Load result with data or null if not found
+     */
+    load(type: string, name: string, options?: MetadataLoadOptions): Promise<MetadataLoadResult>;
+    /**
+     * Load multiple items matching patterns
+     * @param type The metadata type
+     * @param options Load options with patterns
+     * @returns Array of loaded items
+     */
+    loadMany<T = any>(type: string, options?: MetadataLoadOptions): Promise<T[]>;
+    /**
+     * Check if item exists
+     * @param type The metadata type
+     * @param name The item name
+     * @returns True if exists
+     */
+    exists(type: string, name: string): Promise<boolean>;
+    /**
+     * Get item metadata (without loading full content)
+     * @param type The metadata type
+     * @param name The item name
+     * @returns Metadata statistics
+     */
+    stat(type: string, name: string): Promise<MetadataStats | null>;
+    /**
+     * List all items of a type
+     * @param type The metadata type
+     * @returns Array of item names
+     */
+    list(type: string): Promise<string[]>;
+}
+//# sourceMappingURL=loader-interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader-interface.d.ts","sourceRoot":"","sources":["../../src/loaders/loader-interface.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACvB,MAAM,0BAA0B,CAAC;AAElC;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAE1C;;;;;;OAMG;IACH,IAAI,CACF,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE/B;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,GAAG,GAAG,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAEhB;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAErD;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IAEhE;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACvC"}

package/dist/loaders/loader-interface.js

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

package/dist/metadata-manager.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Metadata Manager
+ *
+ * Main orchestrator for metadata loading, saving, and persistence
+ */
+import type { MetadataManagerConfig, MetadataLoadOptions, MetadataSaveOptions, MetadataSaveResult, MetadataWatchEvent } from '@objectstack/spec/system';
+/**
+ * Watch callback function
+ */
+export type WatchCallback = (event: MetadataWatchEvent) => void | Promise<void>;
+/**
+ * Main metadata manager class
+ */
+export declare class MetadataManager {
+    private config;
+    private loader;
+    private serializers;
+    private logger;
+    private watcher?;
+    private watchCallbacks;
+    constructor(config: MetadataManagerConfig);
+    /**
+     * Load a single metadata item
+     */
+    load<T = any>(type: string, name: string, options?: MetadataLoadOptions): Promise<T | null>;
+    /**
+     * Load multiple metadata items
+     */
+    loadMany<T = any>(type: string, options?: MetadataLoadOptions): Promise<T[]>;
+    /**
+     * Save metadata to disk
+     */
+    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>;
+    /**
+     * Start watching for file changes
+     */
+    private startWatching;
+    /**
+     * Handle file change events
+     */
+    private handleFileEvent;
+    /**
+     * Generate ETag for content
+     * Uses SHA-256 hash truncated to 32 characters for reasonable collision resistance
+     * while keeping ETag headers compact (full 64-char hash is overkill for this use case)
+     */
+    private generateETag;
+}
+//# sourceMappingURL=metadata-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-manager.d.ts","sourceRoot":"","sources":["../src/metadata-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,0BAA0B,CAAC;AASlC;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhF;;GAEG;AACH,qBAAa,eAAe;IAOd,OAAO,CAAC,MAAM;IAN1B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAA0C;IAC7D,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAC,CAAY;IAC5B,OAAO,CAAC,cAAc,CAAyC;gBAE3C,MAAM,EAAE,qBAAqB;IA8BjD;;OAEG;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;IAKpB;;OAEG;IACG,QAAQ,CAAC,CAAC,GAAG,GAAG,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC;IAIf;;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;IA2F9B;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1D;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAI3C;;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;IAQnC;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;YACW,eAAe;IAwD7B;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAIrB"}

package/dist/metadata-manager.js

@@ -0,0 +1,263 @@
+/**
+ * Metadata Manager
+ *
+ * Main orchestrator for metadata loading, saving, and persistence
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { watch as chokidarWatch } from 'chokidar';
+import { createLogger } from '@objectstack/core';
+import { FilesystemLoader } from './loaders/filesystem-loader.js';
+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.config = config;
+        this.watchCallbacks = new Map();
+        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 loader
+        const rootDir = config.rootDir || process.cwd();
+        this.loader = new FilesystemLoader(rootDir, this.serializers, this.logger);
+        // Start watching if enabled
+        if (config.watch) {
+            this.startWatching();
+        }
+    }
+    /**
+     * Load a single metadata item
+     */
+    async load(type, name, options) {
+        const result = await this.loader.load(type, name, options);
+        return result.data;
+    }
+    /**
+     * Load multiple metadata items
+     */
+    async loadMany(type, options) {
+        return this.loader.loadMany(type, options);
+    }
+    /**
+     * Save metadata to disk
+     */
+    async save(type, name, data, options) {
+        const startTime = Date.now();
+        const { format = 'typescript', prettify = true, indent = 2, sortKeys = false, backup = false, overwrite = true, atomic = true, path: customPath, } = options || {};
+        try {
+            // Get serializer
+            const serializer = this.serializers.get(format);
+            if (!serializer) {
+                throw new Error(`No serializer found for format: ${format}`);
+            }
+            // Determine file path
+            const typeDir = path.join(this.config.rootDir || process.cwd(), type);
+            const fileName = `${name}${serializer.getExtension()}`;
+            const filePath = customPath || path.join(typeDir, fileName);
+            // Check if file exists
+            if (!overwrite) {
+                try {
+                    await fs.access(filePath);
+                    throw new Error(`File already exists: ${filePath}`);
+                }
+                catch (error) {
+                    // File doesn't exist, continue
+                    if (error.code !== 'ENOENT') {
+                        throw error;
+                    }
+                }
+            }
+            // Create directory if it doesn't exist
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            // Create backup if requested
+            let backupPath;
+            if (backup) {
+                try {
+                    await fs.access(filePath);
+                    backupPath = `${filePath}.bak`;
+                    await fs.copyFile(filePath, backupPath);
+                }
+                catch {
+                    // File doesn't exist, no backup needed
+                }
+            }
+            // Serialize data
+            const content = serializer.serialize(data, {
+                prettify,
+                indent,
+                sortKeys,
+            });
+            // Write to disk (atomic or direct)
+            if (atomic) {
+                const tempPath = `${filePath}.tmp`;
+                await fs.writeFile(tempPath, content, 'utf-8');
+                await fs.rename(tempPath, filePath);
+            }
+            else {
+                await fs.writeFile(filePath, content, 'utf-8');
+            }
+            // Get stats
+            const stats = await fs.stat(filePath);
+            const etag = this.generateETag(content);
+            return {
+                success: true,
+                path: filePath,
+                etag,
+                size: stats.size,
+                saveTime: Date.now() - startTime,
+                backupPath,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to save metadata', undefined, {
+                type,
+                name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Check if metadata item exists
+     */
+    async exists(type, name) {
+        return this.loader.exists(type, name);
+    }
+    /**
+     * List all items of a type
+     */
+    async list(type) {
+        return this.loader.list(type);
+    }
+    /**
+     * 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() {
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = undefined;
+            this.watchCallbacks.clear();
+        }
+    }
+    /**
+     * Start watching for file changes
+     */
+    startWatching() {
+        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
+     */
+    async handleFileEvent(eventType, filePath) {
+        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));
+        const callbacks = this.watchCallbacks.get(type);
+        if (!callbacks || callbacks.size === 0) {
+            return;
+        }
+        let data = 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 = {
+            type: eventType,
+            metadataType: type,
+            name,
+            path: filePath,
+            data,
+            timestamp: new Date(),
+        };
+        for (const callback of callbacks) {
+            try {
+                await callback(event);
+            }
+            catch (error) {
+                this.logger.error('Watch callback error', undefined, {
+                    type,
+                    name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    /**
+     * Generate ETag for content
+     * Uses SHA-256 hash truncated to 32 characters for reasonable collision resistance
+     * while keeping ETag headers compact (full 64-char hash is overkill for this use case)
+     */
+    generateETag(content) {
+        const hash = createHash('sha256').update(content).digest('hex').substring(0, 32);
+        return `"${hash}"`;
+    }
+}

package/dist/serializers/json-serializer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * JSON Metadata Serializer
+ *
+ * Handles JSON format serialization and deserialization
+ */
+import type { z } from 'zod';
+import type { MetadataFormat } from '@objectstack/spec/system';
+import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
+export declare class JSONSerializer implements MetadataSerializer {
+    serialize<T>(item: T, options?: SerializeOptions): string;
+    deserialize<T>(content: string, schema?: z.ZodSchema): T;
+    getExtension(): string;
+    canHandle(format: MetadataFormat): boolean;
+    getFormat(): MetadataFormat;
+    /**
+     * Recursively sort object keys
+     */
+    private sortObjectKeys;
+}
+//# sourceMappingURL=json-serializer.d.ts.map

package/dist/serializers/json-serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-serializer.d.ts","sourceRoot":"","sources":["../../src/serializers/json-serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAEtF,qBAAa,cAAe,YAAW,kBAAkB;IACvD,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAgBzD,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC;IAUxD,YAAY,IAAI,MAAM;IAItB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;IAI1C,SAAS,IAAI,cAAc;IAI3B;;OAEG;IACH,OAAO,CAAC,cAAc;CAkBvB"}