@objectstack/metadata 1.0.2 → 1.0.5

package/dist/index.mjs

@@ -0,0 +1,1040 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/metadata-manager.ts
+import { createLogger } from "@objectstack/core";
+
+// src/serializers/json-serializer.ts
+var JSONSerializer = class {
+  serialize(item, options) {
+    const { prettify = true, indent = 2, sortKeys = false } = options || {};
+    if (sortKeys) {
+      const sorted = this.sortObjectKeys(item);
+      return prettify ? JSON.stringify(sorted, null, indent) : JSON.stringify(sorted);
+    }
+    return prettify ? JSON.stringify(item, null, indent) : JSON.stringify(item);
+  }
+  deserialize(content, schema) {
+    const parsed = JSON.parse(content);
+    if (schema) {
+      return schema.parse(parsed);
+    }
+    return parsed;
+  }
+  getExtension() {
+    return ".json";
+  }
+  canHandle(format) {
+    return format === "json";
+  }
+  getFormat() {
+    return "json";
+  }
+  /**
+   * Recursively sort object keys
+   */
+  sortObjectKeys(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.sortObjectKeys(item));
+    }
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      sorted[key] = this.sortObjectKeys(obj[key]);
+    }
+    return sorted;
+  }
+};
+
+// src/serializers/yaml-serializer.ts
+import * as yaml from "js-yaml";
+var YAMLSerializer = class {
+  serialize(item, options) {
+    const { indent = 2, sortKeys = false } = options || {};
+    return yaml.dump(item, {
+      indent,
+      sortKeys,
+      lineWidth: -1,
+      // Disable line wrapping
+      noRefs: true
+      // Disable YAML references
+    });
+  }
+  deserialize(content, schema) {
+    const parsed = yaml.load(content, { schema: yaml.JSON_SCHEMA });
+    if (schema) {
+      return schema.parse(parsed);
+    }
+    return parsed;
+  }
+  getExtension() {
+    return ".yaml";
+  }
+  canHandle(format) {
+    return format === "yaml";
+  }
+  getFormat() {
+    return "yaml";
+  }
+};
+
+// src/serializers/typescript-serializer.ts
+var TypeScriptSerializer = class {
+  constructor(format = "typescript") {
+    this.format = format;
+  }
+  serialize(item, options) {
+    const { prettify = true, indent = 2 } = options || {};
+    const jsonStr = JSON.stringify(item, null, prettify ? indent : 0);
+    if (this.format === "typescript") {
+      return `import type { ServiceObject } from '@objectstack/spec/data';
+
+export const metadata: ServiceObject = ${jsonStr};
+
+export default metadata;
+`;
+    } else {
+      return `export const metadata = ${jsonStr};
+
+export default metadata;
+`;
+    }
+  }
+  deserialize(content, schema) {
+    let objectStart = content.indexOf("export const");
+    if (objectStart === -1) {
+      objectStart = content.indexOf("export default");
+    }
+    if (objectStart === -1) {
+      throw new Error(
+        'Could not parse TypeScript/JavaScript module. Expected export pattern: "export const metadata = {...};" or "export default {...};"'
+      );
+    }
+    const braceStart = content.indexOf("{", objectStart);
+    if (braceStart === -1) {
+      throw new Error("Could not find object literal in export statement");
+    }
+    let braceCount = 0;
+    let braceEnd = -1;
+    let inString = false;
+    let stringChar = "";
+    for (let i = braceStart; i < content.length; i++) {
+      const char = content[i];
+      const prevChar = i > 0 ? content[i - 1] : "";
+      if ((char === '"' || char === "'") && prevChar !== "\\") {
+        if (!inString) {
+          inString = true;
+          stringChar = char;
+        } else if (char === stringChar) {
+          inString = false;
+          stringChar = "";
+        }
+      }
+      if (!inString) {
+        if (char === "{") braceCount++;
+        if (char === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            braceEnd = i;
+            break;
+          }
+        }
+      }
+    }
+    if (braceEnd === -1) {
+      throw new Error("Could not find matching closing brace for object literal");
+    }
+    const objectLiteral = content.substring(braceStart, braceEnd + 1);
+    try {
+      const parsed = JSON.parse(objectLiteral);
+      if (schema) {
+        return schema.parse(parsed);
+      }
+      return parsed;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse object literal as JSON: ${error instanceof Error ? error.message : String(error)}. Make sure the TypeScript/JavaScript object uses JSON-compatible syntax (no functions, comments, or trailing commas).`
+      );
+    }
+  }
+  getExtension() {
+    return this.format === "typescript" ? ".ts" : ".js";
+  }
+  canHandle(format) {
+    return format === "typescript" || format === "javascript";
+  }
+  getFormat() {
+    return this.format;
+  }
+};
+
+// src/metadata-manager.ts
+var MetadataManager = class {
+  constructor(config) {
+    this.loaders = /* @__PURE__ */ new Map();
+    this.watchCallbacks = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.logger = createLogger({ level: "info", format: "pretty" });
+    this.serializers = /* @__PURE__ */ 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"));
+    }
+    if (config.loaders && config.loaders.length > 0) {
+      config.loaders.forEach((loader) => this.registerLoader(loader));
+    }
+  }
+  /**
+   * 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) {
+    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) {
+          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;
+    let loader;
+    if (targetLoader) {
+      loader = this.loaders.get(targetLoader);
+      if (!loader) {
+        throw new Error(`Loader not found: ${targetLoader}`);
+      }
+    } else {
+      for (const l of this.loaders.values()) {
+        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) {
+        }
+      }
+      if (!loader) {
+        const fsLoader = this.loaders.get("filesystem");
+        if (fsLoader && fsLoader.save) {
+          loader = fsLoader;
+        }
+      }
+      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 = /* @__PURE__ */ 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, /* @__PURE__ */ 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() {
+  }
+  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", void 0, {
+          type,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+};
+
+// src/node-metadata-manager.ts
+import * as path2 from "path";
+import { watch as chokidarWatch } from "chokidar";
+
+// src/loaders/filesystem-loader.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { glob } from "glob";
+import { createHash } from "crypto";
+var FilesystemLoader = class {
+  constructor(rootDir, serializers, logger) {
+    this.rootDir = rootDir;
+    this.serializers = serializers;
+    this.logger = logger;
+    this.contract = {
+      name: "filesystem",
+      protocol: "file",
+      capabilities: {
+        read: true,
+        write: true,
+        watch: true,
+        list: true
+      },
+      supportedFormats: ["json", "yaml", "typescript", "javascript"],
+      supportsWatch: true,
+      supportsWrite: true,
+      supportsCache: true
+    };
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  async load(type, name, options) {
+    const startTime = Date.now();
+    const { validate: _validate = true, useCache = true, ifNoneMatch } = options || {};
+    try {
+      const filePath = await this.findFile(type, name);
+      if (!filePath) {
+        return {
+          data: null,
+          fromCache: false,
+          notModified: false,
+          loadTime: Date.now() - startTime
+        };
+      }
+      const stats = await this.stat(type, name);
+      if (!stats) {
+        return {
+          data: null,
+          fromCache: false,
+          notModified: false,
+          loadTime: Date.now() - startTime
+        };
+      }
+      if (useCache && ifNoneMatch && stats.etag === ifNoneMatch) {
+        return {
+          data: null,
+          fromCache: true,
+          notModified: true,
+          etag: stats.etag,
+          stats,
+          loadTime: Date.now() - startTime
+        };
+      }
+      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
+          };
+        }
+      }
+      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);
+      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", void 0, {
+        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 {
+      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", void 0, {
+        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", void 0, {
+        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 basename3 = path.basename(file, ext);
+        return basename3;
+      });
+    } catch (error) {
+      this.logger?.error("Failed to list", void 0, {
+        type,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  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 {
+      const serializer = this.getSerializer(format);
+      if (!serializer) {
+        throw new Error(`No serializer found for format: ${format}`);
+      }
+      const typeDir = path.join(this.rootDir, type);
+      const fileName = `${name}${serializer.getExtension()}`;
+      const filePath = customPath || path.join(typeDir, fileName);
+      if (!overwrite) {
+        try {
+          await fs.access(filePath);
+          throw new Error(`File already exists: ${filePath}`);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      let backupPath;
+      if (backup) {
+        try {
+          await fs.access(filePath);
+          backupPath = `${filePath}.bak`;
+          await fs.copyFile(filePath, backupPath);
+        } catch {
+        }
+      }
+      const content = serializer.serialize(data, {
+        prettify,
+        indent,
+        sortKeys
+      });
+      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");
+      }
+      return {
+        success: true,
+        path: filePath,
+        // format, // Not in schema
+        size: Buffer.byteLength(content, "utf-8"),
+        backupPath,
+        saveTime: Date.now() - startTime
+      };
+    } catch (error) {
+      this.logger?.error("Failed to save metadata", void 0, {
+        type,
+        name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * 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 {
+      }
+    }
+    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";
+    }
+  }
+  /**
+   * 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}"`;
+  }
+};
+
+// src/node-metadata-manager.ts
+var NodeMetadataManager = class extends MetadataManager {
+  constructor(config) {
+    super(config);
+    if (!config.loaders || config.loaders.length === 0) {
+      const rootDir = config.rootDir || process.cwd();
+      this.registerLoader(new FilesystemLoader(rootDir, this.serializers, this.logger));
+    }
+    if (config.watch) {
+      this.startWatching();
+    }
+  }
+  /**
+   * Stop all watching
+   */
+  async stopWatching() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = void 0;
+    }
+  }
+  /**
+   * 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 = path2.relative(rootDir, filePath);
+    const parts = relativePath.split(path2.sep);
+    if (parts.length < 2) {
+      return;
+    }
+    const type = parts[0];
+    const fileName = parts[parts.length - 1];
+    const name = path2.basename(fileName, path2.extname(fileName));
+    let data = void 0;
+    if (eventType !== "deleted") {
+      try {
+        data = await this.load(type, name, { useCache: false });
+      } catch (error) {
+        this.logger.error("Failed to load changed file", void 0, {
+          filePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return;
+      }
+    }
+    const event = {
+      type: eventType,
+      metadataType: type,
+      name,
+      path: filePath,
+      data,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.notifyWatchers(type, event);
+  }
+};
+
+// src/plugin.ts
+import { ObjectStackDefinitionSchema } from "@objectstack/spec";
+var MetadataPlugin = class {
+  constructor(options = {}) {
+    this.name = "com.objectstack.metadata";
+    this.version = "1.0.0";
+    this.init = async (ctx) => {
+      ctx.logger.info("Initializing Metadata Manager", { root: this.options.rootDir || process.cwd() });
+      ctx.registerService("metadata", this.manager);
+    };
+    this.start = async (ctx) => {
+      ctx.logger.info("Loading metadata...");
+      const metadataTypes = Object.keys(ObjectStackDefinitionSchema.shape).filter((key) => key !== "manifest");
+      for (const type of metadataTypes) {
+        try {
+          const items = await this.manager.loadMany(type, {
+            recursive: true
+          });
+          if (items.length > 0) {
+            ctx.logger.info(`Loaded ${items.length} ${type}`);
+            const ql = ctx.getService("objectql");
+            if (ql && ql.registry) {
+              items.forEach((item) => {
+                const keyField = item.id ? "id" : "name";
+                let registryType = type;
+                if (type === "objects") registryType = "object";
+                if (type === "apps") registryType = "app";
+                if (type === "plugins") registryType = "plugin";
+                if (type === "functions") registryType = "function";
+                ql.registry.registerItem(registryType, item, keyField);
+              });
+            }
+          }
+        } catch (e) {
+        }
+      }
+    };
+    this.options = {
+      watch: true,
+      ...options
+    };
+    const rootDir = this.options.rootDir || process.cwd();
+    this.manager = new NodeMetadataManager({
+      rootDir,
+      watch: this.options.watch ?? true,
+      formats: ["yaml", "json", "typescript", "javascript"]
+    });
+  }
+};
+
+// src/loaders/memory-loader.ts
+var MemoryLoader = class {
+  constructor() {
+    this.contract = {
+      name: "memory",
+      protocol: "memory",
+      capabilities: {
+        read: true,
+        write: true,
+        watch: false,
+        list: true
+      }
+    };
+    // Storage: Type -> Name -> Data
+    this.storage = /* @__PURE__ */ 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: /* @__PURE__ */ 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, /* @__PURE__ */ new Map());
+    }
+    this.storage.get(type).set(name, data);
+    return {
+      success: true,
+      path: `memory://${type}/${name}`,
+      saveTime: 0
+    };
+  }
+};
+
+// src/loaders/remote-loader.ts
+var RemoteLoader = class {
+  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) {
+    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
+    };
+  }
+};
+
+// src/migration/index.ts
+var migration_exports = {};
+__export(migration_exports, {
+  MigrationExecutor: () => MigrationExecutor
+});
+
+// src/migration/executor.ts
+var MigrationExecutor = class {
+  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`);
+    }
+  }
+};
+export {
+  JSONSerializer,
+  MemoryLoader,
+  MetadataManager,
+  MetadataPlugin,
+  migration_exports as Migration,
+  RemoteLoader,
+  TypeScriptSerializer,
+  YAMLSerializer
+};
+//# sourceMappingURL=index.mjs.map