@objectstack/rest 7.0.0 → 7.2.0

package/dist/index.cjs

@@ -1315,6 +1315,40 @@ var RestServer = class {
         }
       });
     }
+    if (metadata.endpoints.items !== false) {
+      this.routeManager.register({
+        method: "GET",
+        path: `${metaPath}/diagnostics`,
+        handler: async (req, res) => {
+          try {
+            const environmentId = isScoped ? req.params?.environmentId : void 0;
+            const p = await this.resolveProtocol(environmentId, req);
+            if (typeof p.getMetaDiagnostics !== "function") {
+              res.status(501).json({
+                error: "not_implemented",
+                message: "protocol.getMetaDiagnostics() is not available in this kernel"
+              });
+              return;
+            }
+            const severityParam = req.query?.severity ?? "error";
+            const severity = severityParam === "warning" ? "warning" : "error";
+            const result = await p.getMetaDiagnostics({
+              type: req.query?.type || void 0,
+              severity,
+              packageId: req.query?.package || void 0
+            });
+            res.json(result);
+          } catch (error) {
+            logError("[REST] Unhandled error:", error);
+            sendError(res, error);
+          }
+        },
+        metadata: {
+          summary: "List metadata entries that fail spec validation",
+          tags: ["metadata"]
+        }
+      });
+    }
     if (metadata.endpoints.items !== false) {
       this.routeManager.register({
         method: "GET",
@@ -1404,7 +1438,8 @@ var RestServer = class {
               return;
             }
             const isAppType = req.params.type === "app";
-            if (metadata.enableCache && p.getMetaItemCached && !isAppType) {
+            const isDraftRead = typeof req.query?.state === "string" && req.query.state.toLowerCase() === "draft";
+            if (metadata.enableCache && p.getMetaItemCached && !isAppType && !isDraftRead) {
               const cacheRequest = {
                 ifNoneMatch: req.headers["if-none-match"],
                 ifModifiedSince: req.headers["if-modified-since"]
@@ -1435,10 +1470,12 @@ var RestServer = class {
               res.json(await this.translateMetaItem(req, req.params.type, environmentId, result.data));
             } else {
               const packageId = req.query?.package || void 0;
+              const stateParam = typeof req.query?.state === "string" ? req.query.state.toLowerCase() : void 0;
               const item = await p.getMetaItem({
                 type: req.params.type,
                 name: req.params.name,
-                packageId
+                packageId,
+                ...stateParam === "draft" ? { state: "draft" } : {}
               });
               let visible = item;
               if (isAppType && item) {
@@ -1497,7 +1534,8 @@ var RestServer = class {
             ...environmentId ? { environmentId } : {},
             ...parentVersion !== void 0 ? { parentVersion } : {},
             ...actor ? { actor } : {},
-            ...force ? { force: true } : {}
+            ...force ? { force: true } : {},
+            ...typeof req.query?.mode === "string" && req.query.mode.toLowerCase() === "draft" ? { mode: "draft" } : {}
           });
           res.json(result);
         } catch (error) {
@@ -1527,12 +1565,14 @@ var RestServer = class {
           const parentVersion = typeof ifMatchHeader === "string" ? ifMatchHeader.replace(/^"|"$/g, "") : void 0;
           const actorHeader = req.headers?.["x-actor"] ?? req.headers?.["X-Actor"] ?? req.user?.id ?? req.userId;
           const actor = typeof actorHeader === "string" ? actorHeader : void 0;
+          const stateParam = typeof req.query?.state === "string" && req.query.state.toLowerCase() === "draft" ? "draft" : void 0;
           const result = await p.deleteMetaItem({
             type: req.params.type,
             name: req.params.name,
             ...environmentId ? { environmentId } : {},
             ...parentVersion !== void 0 ? { parentVersion } : {},
-            ...actor ? { actor } : {}
+            ...actor ? { actor } : {},
+            ...stateParam ? { state: stateParam } : {}
           });
           res.json(result);
         } catch (error) {
@@ -1578,6 +1618,153 @@ var RestServer = class {
         tags: ["metadata"]
       }
     });
+    this.routeManager.register({
+      method: "GET",
+      path: `${metaPath}/:type/:name/audit`,
+      handler: async (req, res) => {
+        try {
+          const environmentId = isScoped ? req.params?.environmentId : void 0;
+          const p = await this.resolveProtocol(environmentId, req);
+          if (typeof p.auditMetaItem !== "function") {
+            res.json({ events: [] });
+            return;
+          }
+          const limit = req.query?.limit !== void 0 ? Number(req.query.limit) : void 0;
+          const result = await p.auditMetaItem({
+            type: req.params.type,
+            name: req.params.name,
+            ...environmentId ? { environmentId } : {},
+            ...limit !== void 0 && Number.isFinite(limit) ? { limit } : {}
+          });
+          res.json(result);
+        } catch (error) {
+          logError("[REST] Unhandled error:", error);
+          sendError(res, error);
+        }
+      },
+      metadata: {
+        summary: "List protection-audit events for a metadata item",
+        tags: ["metadata"]
+      }
+    });
+    this.routeManager.register({
+      method: "POST",
+      path: `${metaPath}/:type/:name/publish`,
+      handler: async (req, res) => {
+        try {
+          const environmentId = isScoped ? req.params?.environmentId : void 0;
+          const p = await this.resolveProtocol(environmentId, req);
+          if (!p.publishMetaItem) {
+            res.status(501).json({
+              error: "Publish operation not supported by protocol implementation"
+            });
+            return;
+          }
+          const actorHeader = req.headers?.["x-actor"] ?? req.headers?.["X-Actor"] ?? req.user?.id ?? req.userId;
+          const actor = typeof actorHeader === "string" ? actorHeader : void 0;
+          const body = req.body && typeof req.body === "object" ? req.body : {};
+          const message = typeof body.message === "string" ? body.message : void 0;
+          const result = await p.publishMetaItem({
+            type: req.params.type,
+            name: req.params.name,
+            ...environmentId ? { environmentId } : {},
+            ...actor ? { actor } : {},
+            ...message ? { message } : {}
+          });
+          res.json(result);
+        } catch (error) {
+          logError("[REST] Unhandled error:", error);
+          sendError(res, error);
+        }
+      },
+      metadata: {
+        summary: "Publish the pending draft overlay (promotes draft \u2192 active)",
+        tags: ["metadata"]
+      }
+    });
+    this.routeManager.register({
+      method: "POST",
+      path: `${metaPath}/:type/:name/rollback`,
+      handler: async (req, res) => {
+        try {
+          const environmentId = isScoped ? req.params?.environmentId : void 0;
+          const p = await this.resolveProtocol(environmentId, req);
+          if (!p.rollbackMetaItem) {
+            res.status(501).json({
+              error: "Rollback operation not supported by protocol implementation"
+            });
+            return;
+          }
+          const body = req.body && typeof req.body === "object" ? req.body : {};
+          const toVersionRaw = body.toVersion ?? body.version ?? req.query?.toVersion;
+          const toVersion = Number(toVersionRaw);
+          if (!Number.isFinite(toVersion) || toVersion < 1) {
+            res.status(400).json({
+              error: `'toVersion' (positive integer) is required`,
+              code: "invalid_request"
+            });
+            return;
+          }
+          const actorHeader = req.headers?.["x-actor"] ?? req.headers?.["X-Actor"] ?? req.user?.id ?? req.userId;
+          const actor = typeof actorHeader === "string" ? actorHeader : void 0;
+          const message = typeof body.message === "string" ? body.message : void 0;
+          const result = await p.rollbackMetaItem({
+            type: req.params.type,
+            name: req.params.name,
+            toVersion,
+            ...environmentId ? { environmentId } : {},
+            ...actor ? { actor } : {},
+            ...message ? { message } : {}
+          });
+          res.json(result);
+        } catch (error) {
+          logError("[REST] Unhandled error:", error);
+          sendError(res, error);
+        }
+      },
+      metadata: {
+        summary: "Restore the body at the given history version as the new live row",
+        tags: ["metadata"]
+      }
+    });
+    this.routeManager.register({
+      method: "GET",
+      path: `${metaPath}/:type/:name/diff`,
+      handler: async (req, res) => {
+        try {
+          const environmentId = isScoped ? req.params?.environmentId : void 0;
+          const p = await this.resolveProtocol(environmentId, req);
+          if (!p.diffMetaItem) {
+            res.status(501).json({
+              error: "Diff operation not supported by protocol implementation"
+            });
+            return;
+          }
+          const parseV = (raw) => {
+            if (raw === void 0 || raw === null || raw === "") return void 0;
+            const n = Number(raw);
+            return Number.isFinite(n) ? n : void 0;
+          };
+          const fromVersion = parseV(req.query?.from ?? req.query?.fromVersion);
+          const toVersion = parseV(req.query?.to ?? req.query?.toVersion);
+          const result = await p.diffMetaItem({
+            type: req.params.type,
+            name: req.params.name,
+            ...environmentId ? { environmentId } : {},
+            ...fromVersion !== void 0 ? { fromVersion } : {},
+            ...toVersion !== void 0 ? { toVersion } : {}
+          });
+          res.json(result);
+        } catch (error) {
+          logError("[REST] Unhandled error:", error);
+          sendError(res, error);
+        }
+      },
+      metadata: {
+        summary: "Diff two metadata versions (from/to query params; omit for previous-vs-current)",
+        tags: ["metadata"]
+      }
+    });
     if (metadata.endpoints.item !== false) {
       this.routeManager.register({
         method: "GET",