@objectstack/objectql 3.0.8 → 3.0.10

package/dist/index.mjs

@@ -491,6 +491,7 @@ SchemaRegistry.namespaceRegistry = /* @__PURE__ */ new Map();
 SchemaRegistry.metadata = /* @__PURE__ */ new Map();
 
 // src/protocol.ts
+import { parseFilterAST, isFilterAST } from "@objectstack/spec/data";
 function simpleHash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {
@@ -518,9 +519,17 @@ var SERVICE_CONFIG = {
   search: { route: "/api/v1/search", plugin: "plugin-search" }
 };
 var ObjectStackProtocolImplementation = class {
-  constructor(engine, getServicesRegistry) {
+  constructor(engine, getServicesRegistry, getFeedService) {
     this.engine = engine;
     this.getServicesRegistry = getServicesRegistry;
+    this.getFeedService = getFeedService;
+  }
+  requireFeedService() {
+    const svc = this.getFeedService?.();
+    if (!svc) {
+      throw new Error("Feed service not available. Install and register service-feed to enable feed operations.");
+    }
+    return svc;
   }
   async getDiscovery() {
     const registeredServices = this.getServicesRegistry ? this.getServicesRegistry() : /* @__PURE__ */ new Map();
@@ -569,16 +578,40 @@ var ObjectStackProtocolImplementation = class {
         }
       }
     }
+    if (registeredServices.has("feed")) {
+      services["feed"] = {
+        enabled: true,
+        status: "available",
+        route: "/api/v1/data",
+        provider: "service-feed"
+      };
+    } else {
+      services["feed"] = {
+        enabled: false,
+        status: "unavailable",
+        message: "Install service-feed to enable"
+      };
+    }
     const routes = {
       data: "/api/v1/data",
       metadata: "/api/v1/meta",
       ...optionalRoutes
     };
+    const capabilities = {
+      feed: registeredServices.has("feed"),
+      comments: registeredServices.has("feed"),
+      automation: registeredServices.has("automation"),
+      cron: registeredServices.has("job"),
+      search: registeredServices.has("search"),
+      export: registeredServices.has("automation") || registeredServices.has("queue"),
+      chunkedUpload: registeredServices.has("file-storage")
+    };
     return {
       version: "1.0",
       apiName: "ObjectStack API",
       routes,
-      services
+      services,
+      capabilities
     };
   }
   async getMetaTypes() {
@@ -685,18 +718,18 @@ var ObjectStackProtocolImplementation = class {
       options.sort = parsed;
       delete options.orderBy;
     }
+    if (options.filters !== void 0 && options.filter === void 0) {
+      options.filter = options.filters;
+    }
+    delete options.filters;
     if (typeof options.filter === "string") {
       try {
         options.filter = JSON.parse(options.filter);
       } catch {
       }
     }
-    if (typeof options.filters === "string") {
-      try {
-        options.filter = JSON.parse(options.filters);
-        delete options.filters;
-      } catch {
-      }
+    if (isFilterAST(options.filter)) {
+      options.filter = parseFilterAST(options.filter);
     }
     if (typeof options.populate === "string") {
       options.populate = options.populate.split(",").map((s) => s.trim()).filter(Boolean);
@@ -1060,6 +1093,137 @@ var ObjectStackProtocolImplementation = class {
       message: "Saved to memory registry"
     };
   }
+  // ==========================================
+  // Feed Operations
+  // ==========================================
+  async listFeed(request) {
+    const svc = this.requireFeedService();
+    const result = await svc.listFeed({
+      object: request.object,
+      recordId: request.recordId,
+      filter: request.type,
+      limit: request.limit,
+      cursor: request.cursor
+    });
+    return { success: true, data: result };
+  }
+  async createFeedItem(request) {
+    const svc = this.requireFeedService();
+    const item = await svc.createFeedItem({
+      object: request.object,
+      recordId: request.recordId,
+      type: request.type,
+      actor: { type: "user", id: "current_user" },
+      body: request.body,
+      mentions: request.mentions,
+      parentId: request.parentId,
+      visibility: request.visibility
+    });
+    return { success: true, data: item };
+  }
+  async updateFeedItem(request) {
+    const svc = this.requireFeedService();
+    const item = await svc.updateFeedItem(request.feedId, {
+      body: request.body,
+      mentions: request.mentions,
+      visibility: request.visibility
+    });
+    return { success: true, data: item };
+  }
+  async deleteFeedItem(request) {
+    const svc = this.requireFeedService();
+    await svc.deleteFeedItem(request.feedId);
+    return { success: true, data: { feedId: request.feedId } };
+  }
+  async addReaction(request) {
+    const svc = this.requireFeedService();
+    const reactions = await svc.addReaction(request.feedId, request.emoji, "current_user");
+    return { success: true, data: { reactions } };
+  }
+  async removeReaction(request) {
+    const svc = this.requireFeedService();
+    const reactions = await svc.removeReaction(request.feedId, request.emoji, "current_user");
+    return { success: true, data: { reactions } };
+  }
+  async pinFeedItem(request) {
+    const svc = this.requireFeedService();
+    const item = await svc.getFeedItem(request.feedId);
+    if (!item) throw new Error(`Feed item ${request.feedId} not found`);
+    await svc.updateFeedItem(request.feedId, { visibility: item.visibility });
+    return { success: true, data: { feedId: request.feedId, pinned: true, pinnedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+  }
+  async unpinFeedItem(request) {
+    const svc = this.requireFeedService();
+    const item = await svc.getFeedItem(request.feedId);
+    if (!item) throw new Error(`Feed item ${request.feedId} not found`);
+    await svc.updateFeedItem(request.feedId, { visibility: item.visibility });
+    return { success: true, data: { feedId: request.feedId, pinned: false } };
+  }
+  async starFeedItem(request) {
+    const svc = this.requireFeedService();
+    const item = await svc.getFeedItem(request.feedId);
+    if (!item) throw new Error(`Feed item ${request.feedId} not found`);
+    await svc.updateFeedItem(request.feedId, { visibility: item.visibility });
+    return { success: true, data: { feedId: request.feedId, starred: true, starredAt: (/* @__PURE__ */ new Date()).toISOString() } };
+  }
+  async unstarFeedItem(request) {
+    const svc = this.requireFeedService();
+    const item = await svc.getFeedItem(request.feedId);
+    if (!item) throw new Error(`Feed item ${request.feedId} not found`);
+    await svc.updateFeedItem(request.feedId, { visibility: item.visibility });
+    return { success: true, data: { feedId: request.feedId, starred: false } };
+  }
+  async searchFeed(request) {
+    const svc = this.requireFeedService();
+    const result = await svc.listFeed({
+      object: request.object,
+      recordId: request.recordId,
+      filter: request.type,
+      limit: request.limit,
+      cursor: request.cursor
+    });
+    const queryLower = (request.query || "").toLowerCase();
+    const filtered = result.items.filter(
+      (item) => item.body?.toLowerCase().includes(queryLower)
+    );
+    return { success: true, data: { items: filtered, total: filtered.length, hasMore: false } };
+  }
+  async getChangelog(request) {
+    const svc = this.requireFeedService();
+    const result = await svc.listFeed({
+      object: request.object,
+      recordId: request.recordId,
+      filter: "changes_only",
+      limit: request.limit,
+      cursor: request.cursor
+    });
+    const entries = result.items.map((item) => ({
+      id: item.id,
+      object: item.object,
+      recordId: item.recordId,
+      actor: item.actor,
+      changes: item.changes || [],
+      timestamp: item.createdAt,
+      source: item.source
+    }));
+    return { success: true, data: { entries, total: result.total, nextCursor: result.nextCursor, hasMore: result.hasMore } };
+  }
+  async feedSubscribe(request) {
+    const svc = this.requireFeedService();
+    const subscription = await svc.subscribe({
+      object: request.object,
+      recordId: request.recordId,
+      userId: "current_user",
+      events: request.events,
+      channels: request.channels
+    });
+    return { success: true, data: subscription };
+  }
+  async feedUnsubscribe(request) {
+    const svc = this.requireFeedService();
+    const unsubscribed = await svc.unsubscribe(request.object, request.recordId, "current_user");
+    return { success: true, data: { object: request.object, recordId: request.recordId, unsubscribed } };
+  }
 };
 
 // src/engine.ts