@objectstack/core 3.0.8 → 3.0.9

package/dist/index.js

@@ -4438,15 +4438,409 @@ var DependencyResolver = class {
     }
   }
 };
+
+// src/namespace-resolver.ts
+var NamespaceResolver = class {
+  constructor(logger) {
+    this.registry = /* @__PURE__ */ new Map();
+    this.logger = logger.child({ component: "NamespaceResolver" });
+  }
+  /**
+   * Register namespaces owned by a package.
+   */
+  register(packageId, namespaces) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const ns of namespaces) {
+      if (this.registry.has(ns)) {
+        const existing = this.registry.get(ns);
+        if (existing.packageId !== packageId) {
+          this.logger.warn("Overwriting namespace entry", { namespace: ns, existing: existing.packageId, incoming: packageId });
+        }
+      }
+      this.registry.set(ns, { namespace: ns, packageId, registeredAt: now });
+      this.logger.debug("Namespace registered", { namespace: ns, packageId });
+    }
+  }
+  /**
+   * Unregister all namespaces belonging to a package.
+   */
+  unregister(packageId) {
+    const removed = [];
+    for (const [ns, entry] of this.registry) {
+      if (entry.packageId === packageId) {
+        this.registry.delete(ns);
+        removed.push(ns);
+      }
+    }
+    this.logger.debug("Namespaces unregistered", { packageId, count: removed.length });
+    return removed;
+  }
+  /**
+   * Check whether a set of namespaces is available for a given package.
+   */
+  checkAvailability(packageId, namespaces) {
+    const conflicts = [];
+    const suggestions = {};
+    for (const ns of namespaces) {
+      const existing = this.registry.get(ns);
+      if (existing && existing.packageId !== packageId) {
+        const suggestion = this.suggestAlternative(ns, packageId);
+        conflicts.push({
+          namespace: ns,
+          existingPackageId: existing.packageId,
+          incomingPackageId: packageId,
+          suggestion
+        });
+        suggestions[ns] = suggestion;
+      }
+    }
+    return {
+      available: conflicts.length === 0,
+      conflicts,
+      suggestions
+    };
+  }
+  /**
+   * Extract namespace strings from a package's metadata definition.
+   */
+  extractNamespaces(config) {
+    const namespaces = [];
+    const categories = [
+      "objects",
+      "views",
+      "pages",
+      "flows",
+      "workflows",
+      "apps",
+      "dashboards",
+      "reports",
+      "actions",
+      "agents"
+    ];
+    for (const category of categories) {
+      const items = config[category];
+      if (Array.isArray(items)) {
+        for (const item of items) {
+          const name = item?.name;
+          if (typeof name === "string") {
+            namespaces.push(`${category}.${name}`);
+          }
+        }
+      } else if (items && typeof items === "object") {
+        for (const key of Object.keys(items)) {
+          namespaces.push(`${category}.${key}`);
+        }
+      }
+    }
+    return namespaces;
+  }
+  /**
+   * Get all registered entries.
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Get all namespaces belonging to a specific package.
+   */
+  getPackageNamespaces(packageId) {
+    const namespaces = [];
+    for (const [ns, entry] of this.registry) {
+      if (entry.packageId === packageId) {
+        namespaces.push(ns);
+      }
+    }
+    return namespaces;
+  }
+  /**
+   * Generate a prefixed alternative namespace to avoid conflicts.
+   */
+  suggestAlternative(ns, packageId) {
+    const shortName = packageId.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").replace(/-/g, "_");
+    const parts = ns.split(".");
+    if (parts.length >= 2) {
+      return `${parts[0]}.${shortName}_${parts.slice(1).join(".")}`;
+    }
+    return `${shortName}_${ns}`;
+  }
+};
+
+// src/package-manager.ts
+var PackageManager = class {
+  constructor(logger, options = {}) {
+    this.packages = /* @__PURE__ */ new Map();
+    this.snapshots = /* @__PURE__ */ new Map();
+    this.logger = logger.child({ component: "PackageManager" });
+    this.dependencyResolver = new DependencyResolver(logger);
+    this.namespaceResolver = new NamespaceResolver(logger);
+    this.platformVersion = options.platformVersion || "3.0.0";
+  }
+  /**
+   * Install a package with full dependency resolution and namespace checking.
+   */
+  async install(packageId, version, manifest) {
+    this.logger.info("Installing package", { packageId, version });
+    if (this.packages.has(packageId)) {
+      const existing = this.packages.get(packageId);
+      if (existing.status === "installed") {
+        return {
+          success: false,
+          packageId,
+          version,
+          installedDependencies: [],
+          namespaceConflicts: [],
+          errorMessage: `Package ${packageId}@${existing.version} is already installed. Use upgrade instead.`
+        };
+      }
+    }
+    const engine = manifest.engine?.objectstack;
+    if (engine) {
+      const platformSemver = SemanticVersionManager.parse(this.platformVersion);
+      if (!SemanticVersionManager.satisfies(platformSemver, engine)) {
+        return {
+          success: false,
+          packageId,
+          version,
+          installedDependencies: [],
+          namespaceConflicts: [],
+          errorMessage: `Package requires platform ${engine}, but current platform is v${this.platformVersion}`
+        };
+      }
+    }
+    const namespaces = this.namespaceResolver.extractNamespaces(manifest);
+    const nsCheck = this.namespaceResolver.checkAvailability(packageId, namespaces);
+    if (!nsCheck.available) {
+      return {
+        success: false,
+        packageId,
+        version,
+        installedDependencies: [],
+        namespaceConflicts: nsCheck.conflicts.map((c) => ({
+          namespace: c.namespace,
+          existingPackageId: c.existingPackageId
+        })),
+        errorMessage: `Namespace conflicts detected: ${nsCheck.conflicts.map((c) => c.namespace).join(", ")}`
+      };
+    }
+    const deps = manifest.dependencies;
+    const depNames = deps ? Object.keys(deps) : [];
+    const missingDeps = depNames.filter((d) => !this.packages.has(d));
+    if (missingDeps.length > 0) {
+      return {
+        success: false,
+        packageId,
+        version,
+        installedDependencies: [],
+        namespaceConflicts: [],
+        errorMessage: `Missing dependencies: ${missingDeps.join(", ")}`
+      };
+    }
+    this.packages.set(packageId, {
+      packageId,
+      version,
+      manifest,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "installed",
+      namespaces,
+      dependencies: depNames
+    });
+    this.namespaceResolver.register(packageId, namespaces);
+    this.logger.info("Package installed", { packageId, version, namespaces: namespaces.length });
+    return {
+      success: true,
+      packageId,
+      version,
+      installedDependencies: depNames,
+      namespaceConflicts: []
+    };
+  }
+  /**
+   * Uninstall a package, checking for dependents first.
+   */
+  async uninstall(packageId) {
+    const pkg = this.packages.get(packageId);
+    if (!pkg) {
+      return { success: false, errorMessage: `Package ${packageId} is not installed` };
+    }
+    const dependents = [];
+    for (const [id, record] of this.packages) {
+      if (id !== packageId && record.dependencies.includes(packageId)) {
+        dependents.push(id);
+      }
+    }
+    if (dependents.length > 0) {
+      return {
+        success: false,
+        errorMessage: `Cannot uninstall ${packageId}: depended upon by ${dependents.join(", ")}`
+      };
+    }
+    this.namespaceResolver.unregister(packageId);
+    this.packages.delete(packageId);
+    this.snapshots.delete(packageId);
+    this.logger.info("Package uninstalled", { packageId });
+    return { success: true };
+  }
+  /**
+   * Upgrade a package: snapshot → update → register.
+   */
+  async upgrade(packageId, newVersion, newManifest) {
+    const existing = this.packages.get(packageId);
+    if (!existing) {
+      return {
+        success: false,
+        packageId,
+        fromVersion: "",
+        toVersion: newVersion,
+        snapshot: { packageId, previousVersion: "", previousManifest: {}, previousNamespaces: [], installedAt: "", createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+        errorMessage: `Package ${packageId} is not installed`
+      };
+    }
+    const snapshot = {
+      packageId,
+      previousVersion: existing.version,
+      previousManifest: existing.manifest,
+      previousNamespaces: [...existing.namespaces],
+      installedAt: existing.installedAt,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.snapshots.set(packageId, snapshot);
+    const engine = newManifest.engine?.objectstack;
+    if (engine) {
+      const platformSemver = SemanticVersionManager.parse(this.platformVersion);
+      if (!SemanticVersionManager.satisfies(platformSemver, engine)) {
+        return {
+          success: false,
+          packageId,
+          fromVersion: existing.version,
+          toVersion: newVersion,
+          snapshot,
+          errorMessage: `New version requires platform ${engine}, current is v${this.platformVersion}`
+        };
+      }
+    }
+    const newNamespaces = this.namespaceResolver.extractNamespaces(newManifest);
+    this.namespaceResolver.unregister(packageId);
+    const nsCheck = this.namespaceResolver.checkAvailability(packageId, newNamespaces);
+    if (!nsCheck.available) {
+      this.namespaceResolver.register(packageId, existing.namespaces);
+      return {
+        success: false,
+        packageId,
+        fromVersion: existing.version,
+        toVersion: newVersion,
+        snapshot,
+        errorMessage: `Namespace conflicts in new version: ${nsCheck.conflicts.map((c) => c.namespace).join(", ")}`
+      };
+    }
+    this.namespaceResolver.register(packageId, newNamespaces);
+    const deps = newManifest.dependencies;
+    this.packages.set(packageId, {
+      packageId,
+      version: newVersion,
+      manifest: newManifest,
+      installedAt: existing.installedAt,
+      status: "installed",
+      namespaces: newNamespaces,
+      dependencies: deps ? Object.keys(deps) : []
+    });
+    this.logger.info("Package upgraded", { packageId, from: existing.version, to: newVersion });
+    return {
+      success: true,
+      packageId,
+      fromVersion: existing.version,
+      toVersion: newVersion,
+      snapshot
+    };
+  }
+  /**
+   * Rollback a package to its pre-upgrade snapshot.
+   */
+  async rollback(packageId) {
+    const snapshot = this.snapshots.get(packageId);
+    if (!snapshot) {
+      return {
+        success: false,
+        packageId,
+        restoredVersion: "",
+        errorMessage: `No upgrade snapshot found for ${packageId}`
+      };
+    }
+    this.namespaceResolver.unregister(packageId);
+    this.namespaceResolver.register(packageId, snapshot.previousNamespaces);
+    const deps = snapshot.previousManifest.dependencies;
+    this.packages.set(packageId, {
+      packageId,
+      version: snapshot.previousVersion,
+      manifest: snapshot.previousManifest,
+      installedAt: snapshot.installedAt,
+      status: "installed",
+      namespaces: snapshot.previousNamespaces,
+      dependencies: deps ? Object.keys(deps) : []
+    });
+    this.snapshots.delete(packageId);
+    this.logger.info("Package rolled back", { packageId, to: snapshot.previousVersion });
+    return {
+      success: true,
+      packageId,
+      restoredVersion: snapshot.previousVersion
+    };
+  }
+  /**
+   * Get an installed package record.
+   */
+  getPackage(packageId) {
+    return this.packages.get(packageId);
+  }
+  /**
+   * List all installed packages.
+   */
+  listPackages() {
+    return Array.from(this.packages.values());
+  }
+  /**
+   * Resolve dependencies for a set of packages.
+   */
+  resolveDependencies(packages) {
+    return this.dependencyResolver.resolve(packages);
+  }
+  /**
+   * Check namespace availability for a package's metadata.
+   */
+  checkNamespaces(packageId, config) {
+    const namespaces = this.namespaceResolver.extractNamespaces(config);
+    const result = this.namespaceResolver.checkAvailability(packageId, namespaces);
+    return {
+      available: result.available,
+      conflicts: result.conflicts.map((c) => ({
+        namespace: c.namespace,
+        existingPackageId: c.existingPackageId
+      }))
+    };
+  }
+  /**
+   * Get the namespace resolver instance.
+   */
+  getNamespaceResolver() {
+    return this.namespaceResolver;
+  }
+  /**
+   * Get a snapshot for a given package (if available).
+   */
+  getSnapshot(packageId) {
+    return this.snapshots.get(packageId);
+  }
+};
 export {
   ApiRegistry,
   CORE_FALLBACK_FACTORIES,
   DependencyResolver,
   HotReloadManager,
   LiteKernel,
+  NamespaceResolver,
   ObjectKernel,
   ObjectKernelBase,
   ObjectLogger,
+  PackageManager,
   PluginConfigValidator,
   PluginHealthMonitor,
   PluginLoader,