@objectstack/metadata 3.0.10 → 3.1.0

package/dist/index.mjs

@@ -786,6 +786,156 @@ var MetadataManager = class {
       }
     }
   }
+  /**
+   * Publish an entire package:
+   * 1. Validate all draft items
+   * 2. Snapshot all items in the package (publishedDefinition = clone(metadata))
+   * 3. Increment version
+   * 4. Set all items state → active
+   */
+  async publishPackage(packageId, options) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const shouldValidate = options?.validate !== false;
+    const publishedBy = options?.publishedBy;
+    const packageItems = [];
+    for (const [type, typeStore] of this.registry) {
+      for (const [name, data] of typeStore) {
+        const meta = data;
+        if (meta?.packageId === packageId || meta?.package === packageId) {
+          packageItems.push({ type, name, data: meta });
+        }
+      }
+    }
+    if (packageItems.length === 0) {
+      return {
+        success: false,
+        packageId,
+        version: 0,
+        publishedAt: now,
+        itemsPublished: 0,
+        validationErrors: [{ type: "", name: "", message: `No metadata items found for package '${packageId}'` }]
+      };
+    }
+    if (shouldValidate) {
+      const validationErrors = [];
+      for (const item of packageItems) {
+        const result = await this.validate(item.type, item.data);
+        if (!result.valid && result.errors) {
+          for (const err of result.errors) {
+            validationErrors.push({
+              type: item.type,
+              name: item.name,
+              message: err.message
+            });
+          }
+        }
+      }
+      const packageItemKeys = new Set(packageItems.map((i) => `${i.type}:${i.name}`));
+      for (const item of packageItems) {
+        const deps = await this.getDependencies(item.type, item.name);
+        for (const dep of deps) {
+          const depKey = `${dep.targetType}:${dep.targetName}`;
+          if (packageItemKeys.has(depKey)) continue;
+          const depItem = await this.get(dep.targetType, dep.targetName);
+          if (!depItem) {
+            validationErrors.push({
+              type: item.type,
+              name: item.name,
+              message: `Dependency '${dep.targetType}:${dep.targetName}' not found`
+            });
+          } else {
+            const depMeta = depItem;
+            if (depMeta.publishedDefinition === void 0 && depMeta.state !== "active") {
+              validationErrors.push({
+                type: item.type,
+                name: item.name,
+                message: `Dependency '${dep.targetType}:${dep.targetName}' is not published`
+              });
+            }
+          }
+        }
+      }
+      if (validationErrors.length > 0) {
+        return {
+          success: false,
+          packageId,
+          version: 0,
+          publishedAt: now,
+          itemsPublished: 0,
+          validationErrors
+        };
+      }
+    }
+    let maxVersion = 0;
+    for (const item of packageItems) {
+      const v = typeof item.data.version === "number" ? item.data.version : 0;
+      if (v > maxVersion) maxVersion = v;
+    }
+    const newVersion = maxVersion + 1;
+    for (const item of packageItems) {
+      const updated = {
+        ...item.data,
+        publishedDefinition: structuredClone(item.data.metadata ?? item.data),
+        publishedAt: now,
+        publishedBy: publishedBy ?? item.data.publishedBy,
+        version: newVersion,
+        state: "active"
+      };
+      await this.register(item.type, item.name, updated);
+    }
+    return {
+      success: true,
+      packageId,
+      version: newVersion,
+      publishedAt: now,
+      itemsPublished: packageItems.length
+    };
+  }
+  /**
+   * Revert entire package to last published state.
+   * Restores all metadata definitions from their published snapshots.
+   */
+  async revertPackage(packageId) {
+    const packageItems = [];
+    for (const [type, typeStore] of this.registry) {
+      for (const [name, data] of typeStore) {
+        const meta = data;
+        if (meta?.packageId === packageId || meta?.package === packageId) {
+          packageItems.push({ type, name, data: meta });
+        }
+      }
+    }
+    if (packageItems.length === 0) {
+      throw new Error(`No metadata items found for package '${packageId}'`);
+    }
+    const hasPublished = packageItems.some((item) => item.data.publishedDefinition !== void 0);
+    if (!hasPublished) {
+      throw new Error(`Package '${packageId}' has never been published`);
+    }
+    for (const item of packageItems) {
+      if (item.data.publishedDefinition !== void 0) {
+        const reverted = {
+          ...item.data,
+          metadata: structuredClone(item.data.publishedDefinition),
+          state: "active"
+        };
+        await this.register(item.type, item.name, reverted);
+      }
+    }
+  }
+  /**
+   * Get the published version of any metadata item (for runtime serving).
+   * Returns publishedDefinition if exists, else current definition.
+   */
+  async getPublished(type, name) {
+    const item = await this.get(type, name);
+    if (!item) return void 0;
+    const meta = item;
+    if (meta.publishedDefinition !== void 0) {
+      return meta.publishedDefinition;
+    }
+    return meta.metadata ?? item;
+  }
   // ==========================================
   // Query / Search
   // ==========================================