@objectstack/metadata 1.0.4 → 1.0.6

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @objectstack/metadata@1.0.6 build /home/runner/work/spec/spec/packages/metadata
+> tsup --config ../../tsup.config.ts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/spec/spec/tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.mjs     28.54 KB
+ESM dist/index.mjs.map 60.57 KB
+ESM ⚡️ Build success in 79ms
+CJS dist/index.js     30.34 KB
+CJS dist/index.js.map 61.88 KB
+CJS ⚡️ Build success in 88ms
+DTS Build start
+DTS ⚡️ Build success in 9382ms
+DTS dist/index.d.mts 9.91 KB
+DTS dist/index.d.ts  9.91 KB

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @objectstack/metadata
 
+## 1.0.6
+
+### Patch Changes
+
+- Updated dependencies [a7f7b9d]
+  - @objectstack/spec@1.0.6
+  - @objectstack/core@1.0.6
+  - @objectstack/types@1.0.6
+
+## 1.0.5
+
+### Patch Changes
+
+- b1d24bd: refactor: migrate build system from tsc to tsup for faster builds
+  - Replaced `tsc` with `tsup` (using esbuild) across all packages
+  - Added shared `tsup.config.ts` in workspace root
+  - Added `tsup` as workspace dev dependency
+  - significantly improved build performance
+- Updated dependencies [b1d24bd]
+  - @objectstack/core@1.0.5
+  - @objectstack/types@1.0.5
+  - @objectstack/spec@1.0.5
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,306 @@
+import { MetadataFormat, MetadataLoaderContract, MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataSaveOptions, MetadataSaveResult, MetadataWatchEvent, MetadataManagerConfig } from '@objectstack/spec/system';
+export { MetadataCollectionInfo, MetadataExportOptions, MetadataFormat, MetadataImportOptions, MetadataLoadOptions, MetadataLoadResult, MetadataLoaderContract, MetadataManagerConfig, MetadataSaveOptions, MetadataSaveResult, MetadataStats, MetadataWatchEvent } from '@objectstack/spec/system';
+import { Logger, Plugin, PluginContext } from '@objectstack/core';
+import { z } from 'zod';
+import { System } from '@objectstack/spec';
+import { ISchemaDriver } from '@objectstack/spec/contracts';
+
+/**
+ * Metadata Serializer Interface
+ *
+ * Defines the contract for serializing/deserializing metadata
+ */
+
+/**
+ * Serialization options
+ */
+interface SerializeOptions {
+    /** Prettify output (formatted with indentation) */
+    prettify?: boolean;
+    /** Indentation size (spaces) */
+    indent?: number;
+    /** Sort object keys alphabetically */
+    sortKeys?: boolean;
+    /** Include default values in output */
+    includeDefaults?: boolean;
+}
+/**
+ * Abstract interface for metadata serializers
+ * Implementations handle different formats (JSON, YAML, TypeScript, etc.)
+ */
+interface MetadataSerializer {
+    /**
+     * Serialize object to string
+     * @param item The item to serialize
+     * @param options Serialization options
+     * @returns Serialized string
+     */
+    serialize<T>(item: T, options?: SerializeOptions): string;
+    /**
+     * Deserialize string to object
+     * @param content The content to deserialize
+     * @param schema Optional Zod schema for validation
+     * @returns Deserialized object
+     */
+    deserialize<T>(content: string, schema?: z.ZodSchema): T;
+    /**
+     * Get file extension for this format
+     * @returns File extension (e.g., '.json', '.yaml')
+     */
+    getExtension(): string;
+    /**
+     * Check if this serializer can handle the format
+     * @param format The format to check
+     * @returns True if can handle
+     */
+    canHandle(format: MetadataFormat): boolean;
+    /**
+     * Get the format this serializer handles
+     * @returns The metadata format
+     */
+    getFormat(): MetadataFormat;
+}
+
+/**
+ * Metadata Loader Interface
+ *
+ * Defines the contract for loading metadata from various sources
+ */
+
+/**
+ * Abstract interface for metadata loaders
+ * Implementations can load from filesystem, HTTP, S3, databases, etc.
+ */
+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[]>;
+    /**
+     * Save metadata item
+     * @param type The metadata type
+     * @param name The item name
+     * @param data The data to save
+     * @param options Save options
+     */
+    save?(type: string, name: string, data: any, options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
+}
+
+/**
+ * Metadata Manager
+ *
+ * Main orchestrator for metadata loading, saving, and persistence.
+ * Browser-compatible (Pure).
+ */
+
+/**
+ * Watch callback function
+ */
+type WatchCallback = (event: MetadataWatchEvent) => void | Promise<void>;
+interface MetadataManagerOptions extends MetadataManagerConfig {
+    loaders?: MetadataLoader[];
+}
+/**
+ * Main metadata manager class
+ */
+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;
+}
+
+interface MetadataPluginOptions {
+    rootDir?: string;
+    watch?: boolean;
+}
+declare class MetadataPlugin implements Plugin {
+    name: string;
+    version: string;
+    private manager;
+    private options;
+    constructor(options?: MetadataPluginOptions);
+    init: (ctx: PluginContext) => Promise<void>;
+    start: (ctx: PluginContext) => Promise<void>;
+}
+
+/**
+ * Memory Metadata Loader
+ *
+ * Stores metadata in memory only. Changes are lost when process restarts.
+ * Useful for testing, temporary overrides, or "dirty" edits.
+ */
+
+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>;
+}
+
+/**
+ * Remote Metadata Loader
+ *
+ * Loads metadata from an HTTP API.
+ * This loader is stateless and delegates storage to the remote server.
+ */
+
+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>;
+}
+
+/**
+ * JSON Metadata Serializer
+ *
+ * Handles JSON format serialization and deserialization
+ */
+
+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;
+}
+
+/**
+ * YAML Metadata Serializer
+ *
+ * Handles YAML format serialization and deserialization
+ */
+
+declare class YAMLSerializer 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;
+}
+
+declare class MigrationExecutor {
+    private driver;
+    constructor(driver: ISchemaDriver);
+    executeChangeSet(changeSet: System.ChangeSet): Promise<void>;
+    private executeOperation;
+}
+
+type index_MigrationExecutor = MigrationExecutor;
+declare const index_MigrationExecutor: typeof MigrationExecutor;
+declare namespace index {
+  export { index_MigrationExecutor as MigrationExecutor };
+}
+
+/**
+ * TypeScript/JavaScript Metadata Serializer
+ *
+ * Handles TypeScript/JavaScript module format serialization and deserialization
+ */
+
+declare class TypeScriptSerializer implements MetadataSerializer {
+    private format;
+    constructor(format?: 'typescript' | 'javascript');
+    serialize<T>(item: T, options?: SerializeOptions): string;
+    deserialize<T>(content: string, schema?: z.ZodSchema): T;
+    getExtension(): string;
+    canHandle(format: MetadataFormat): boolean;
+    getFormat(): MetadataFormat;
+}
+
+export { JSONSerializer, MemoryLoader, type MetadataLoader, MetadataManager, type MetadataManagerOptions, MetadataPlugin, type MetadataSerializer, index as Migration, RemoteLoader, type SerializeOptions, TypeScriptSerializer, type WatchCallback, YAMLSerializer };

package/dist/index.d.ts

@@ -1,17 +1,306 @@
+import { MetadataFormat, MetadataLoaderContract, MetadataLoadOptions, MetadataLoadResult, MetadataStats, MetadataSaveOptions, MetadataSaveResult, MetadataWatchEvent, MetadataManagerConfig } from '@objectstack/spec/system';
+export { MetadataCollectionInfo, MetadataExportOptions, MetadataFormat, MetadataImportOptions, MetadataLoadOptions, MetadataLoadResult, MetadataLoaderContract, MetadataManagerConfig, MetadataSaveOptions, MetadataSaveResult, MetadataStats, MetadataWatchEvent } from '@objectstack/spec/system';
+import { Logger, Plugin, PluginContext } from '@objectstack/core';
+import { z } from 'zod';
+import { System } from '@objectstack/spec';
+import { ISchemaDriver } from '@objectstack/spec/contracts';
+
 /**
- * @objectstack/metadata
- *
- * Metadata loading, saving, and persistence for ObjectStack
- */
-export { MetadataManager, type WatchCallback, type MetadataManagerOptions } from './metadata-manager.js';
-export { MetadataPlugin } from './plugin.js';
-export { type MetadataLoader } from './loaders/loader-interface.js';
-export { MemoryLoader } from './loaders/memory-loader.js';
-export { RemoteLoader } from './loaders/remote-loader.js';
-export { type MetadataSerializer, type SerializeOptions } from './serializers/serializer-interface.js';
-export { JSONSerializer } from './serializers/json-serializer.js';
-export { YAMLSerializer } from './serializers/yaml-serializer.js';
-export * as Migration from './migration/index.js';
-export { TypeScriptSerializer } from './serializers/typescript-serializer.js';
-export type { MetadataFormat, MetadataStats, MetadataLoadOptions, MetadataSaveOptions, MetadataExportOptions, MetadataImportOptions, MetadataLoadResult, MetadataSaveResult, MetadataWatchEvent, MetadataCollectionInfo, MetadataLoaderContract, MetadataManagerConfig, } from '@objectstack/spec/system';
-//# sourceMappingURL=index.d.ts.map
+ * Metadata Serializer Interface
+ *
+ * Defines the contract for serializing/deserializing metadata
+ */
+
+/**
+ * Serialization options
+ */
+interface SerializeOptions {
+    /** Prettify output (formatted with indentation) */
+    prettify?: boolean;
+    /** Indentation size (spaces) */
+    indent?: number;
+    /** Sort object keys alphabetically */
+    sortKeys?: boolean;
+    /** Include default values in output */
+    includeDefaults?: boolean;
+}
+/**
+ * Abstract interface for metadata serializers
+ * Implementations handle different formats (JSON, YAML, TypeScript, etc.)
+ */
+interface MetadataSerializer {
+    /**
+     * Serialize object to string
+     * @param item The item to serialize
+     * @param options Serialization options
+     * @returns Serialized string
+     */
+    serialize<T>(item: T, options?: SerializeOptions): string;
+    /**
+     * Deserialize string to object
+     * @param content The content to deserialize
+     * @param schema Optional Zod schema for validation
+     * @returns Deserialized object
+     */
+    deserialize<T>(content: string, schema?: z.ZodSchema): T;
+    /**
+     * Get file extension for this format
+     * @returns File extension (e.g., '.json', '.yaml')
+     */
+    getExtension(): string;
+    /**
+     * Check if this serializer can handle the format
+     * @param format The format to check
+     * @returns True if can handle
+     */
+    canHandle(format: MetadataFormat): boolean;
+    /**
+     * Get the format this serializer handles
+     * @returns The metadata format
+     */
+    getFormat(): MetadataFormat;
+}
+
+/**
+ * Metadata Loader Interface
+ *
+ * Defines the contract for loading metadata from various sources
+ */
+
+/**
+ * Abstract interface for metadata loaders
+ * Implementations can load from filesystem, HTTP, S3, databases, etc.
+ */
+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[]>;
+    /**
+     * Save metadata item
+     * @param type The metadata type
+     * @param name The item name
+     * @param data The data to save
+     * @param options Save options
+     */
+    save?(type: string, name: string, data: any, options?: MetadataSaveOptions): Promise<MetadataSaveResult>;
+}
+
+/**
+ * Metadata Manager
+ *
+ * Main orchestrator for metadata loading, saving, and persistence.
+ * Browser-compatible (Pure).
+ */
+
+/**
+ * Watch callback function
+ */
+type WatchCallback = (event: MetadataWatchEvent) => void | Promise<void>;
+interface MetadataManagerOptions extends MetadataManagerConfig {
+    loaders?: MetadataLoader[];
+}
+/**
+ * Main metadata manager class
+ */
+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;
+}
+
+interface MetadataPluginOptions {
+    rootDir?: string;
+    watch?: boolean;
+}
+declare class MetadataPlugin implements Plugin {
+    name: string;
+    version: string;
+    private manager;
+    private options;
+    constructor(options?: MetadataPluginOptions);
+    init: (ctx: PluginContext) => Promise<void>;
+    start: (ctx: PluginContext) => Promise<void>;
+}
+
+/**
+ * Memory Metadata Loader
+ *
+ * Stores metadata in memory only. Changes are lost when process restarts.
+ * Useful for testing, temporary overrides, or "dirty" edits.
+ */
+
+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>;
+}
+
+/**
+ * Remote Metadata Loader
+ *
+ * Loads metadata from an HTTP API.
+ * This loader is stateless and delegates storage to the remote server.
+ */
+
+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>;
+}
+
+/**
+ * JSON Metadata Serializer
+ *
+ * Handles JSON format serialization and deserialization
+ */
+
+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;
+}
+
+/**
+ * YAML Metadata Serializer
+ *
+ * Handles YAML format serialization and deserialization
+ */
+
+declare class YAMLSerializer 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;
+}
+
+declare class MigrationExecutor {
+    private driver;
+    constructor(driver: ISchemaDriver);
+    executeChangeSet(changeSet: System.ChangeSet): Promise<void>;
+    private executeOperation;
+}
+
+type index_MigrationExecutor = MigrationExecutor;
+declare const index_MigrationExecutor: typeof MigrationExecutor;
+declare namespace index {
+  export { index_MigrationExecutor as MigrationExecutor };
+}
+
+/**
+ * TypeScript/JavaScript Metadata Serializer
+ *
+ * Handles TypeScript/JavaScript module format serialization and deserialization
+ */
+
+declare class TypeScriptSerializer implements MetadataSerializer {
+    private format;
+    constructor(format?: 'typescript' | 'javascript');
+    serialize<T>(item: T, options?: SerializeOptions): string;
+    deserialize<T>(content: string, schema?: z.ZodSchema): T;
+    getExtension(): string;
+    canHandle(format: MetadataFormat): boolean;
+    getFormat(): MetadataFormat;
+}
+
+export { JSONSerializer, MemoryLoader, type MetadataLoader, MetadataManager, type MetadataManagerOptions, MetadataPlugin, type MetadataSerializer, index as Migration, RemoteLoader, type SerializeOptions, TypeScriptSerializer, type WatchCallback, YAMLSerializer };