@objectstack/objectql 3.0.8 → 3.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/objectql",
-  "version": "3.0.8",
+  "version": "3.0.10",
   "license": "Apache-2.0",
   "description": "Isomorphic ObjectQL Engine for ObjectStack",
   "main": "dist/index.js",
@@ -13,9 +13,9 @@
     }
   },
   "dependencies": {
-    "@objectstack/core": "3.0.8",
-    "@objectstack/spec": "3.0.8",
-    "@objectstack/types": "3.0.8"
+    "@objectstack/core": "3.0.10",
+    "@objectstack/spec": "3.0.10",
+    "@objectstack/types": "3.0.10"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/protocol-discovery.test.ts

@@ -137,17 +137,77 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     expect(discovery.services.analytics.route).toBe('/api/v1/analytics');
   });
 
-  it('should not return capabilities field (removed — use services instead)', async () => {
+  it('should return capabilities field populated from registered services', async () => {
     const mockServices = new Map<string, any>();
     mockServices.set('workflow', {});
     
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
     
-    // capabilities field should no longer exist in the response
-    const keys = Object.keys(discovery);
-    expect(keys).not.toContain('capabilities');
-    // Use services to check availability instead
+    // capabilities field should now exist in the response
+    expect(discovery.capabilities).toBeDefined();
+    // workflow is registered but doesn't map to a well-known capability directly
     expect(discovery.services.workflow.enabled).toBe(true);
+    // All well-known capabilities should be false since workflow doesn't map to any
+    expect(discovery.capabilities!.feed).toBe(false);
+    expect(discovery.capabilities!.comments).toBe(false);
+    expect(discovery.capabilities!.automation).toBe(false);
+    expect(discovery.capabilities!.cron).toBe(false);
+    expect(discovery.capabilities!.search).toBe(false);
+    expect(discovery.capabilities!.export).toBe(false);
+    expect(discovery.capabilities!.chunkedUpload).toBe(false);
+  });
+
+  it('should set all capabilities to false when no services are registered', async () => {
+    protocol = new ObjectStackProtocolImplementation(engine);
+    const discovery = await protocol.getDiscovery();
+
+    expect(discovery.capabilities).toBeDefined();
+    expect(discovery.capabilities!.feed).toBe(false);
+    expect(discovery.capabilities!.comments).toBe(false);
+    expect(discovery.capabilities!.automation).toBe(false);
+    expect(discovery.capabilities!.cron).toBe(false);
+    expect(discovery.capabilities!.search).toBe(false);
+    expect(discovery.capabilities!.export).toBe(false);
+    expect(discovery.capabilities!.chunkedUpload).toBe(false);
+  });
+
+  it('should dynamically set capabilities based on registered services', async () => {
+    const mockServices = new Map<string, any>();
+    mockServices.set('feed', {});
+    mockServices.set('automation', {});
+    mockServices.set('search', {});
+    mockServices.set('file-storage', {});
+
+    protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
+    const discovery = await protocol.getDiscovery();
+
+    expect(discovery.capabilities!.feed).toBe(true);
+    expect(discovery.capabilities!.comments).toBe(true);
+    expect(discovery.capabilities!.automation).toBe(true);
+    expect(discovery.capabilities!.cron).toBe(false);
+    expect(discovery.capabilities!.search).toBe(true);
+    expect(discovery.capabilities!.export).toBe(true);
+    expect(discovery.capabilities!.chunkedUpload).toBe(true);
+  });
+
+  it('should enable cron capability when job service is registered', async () => {
+    const mockServices = new Map<string, any>();
+    mockServices.set('job', {});
+
+    protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
+    const discovery = await protocol.getDiscovery();
+
+    expect(discovery.capabilities!.cron).toBe(true);
+  });
+
+  it('should enable export capability when queue service is registered', async () => {
+    const mockServices = new Map<string, any>();
+    mockServices.set('queue', {});
+
+    protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
+    const discovery = await protocol.getDiscovery();
+
+    expect(discovery.capabilities!.export).toBe(true);
   });
 });

package/src/protocol-feed.test.ts

@@ -0,0 +1,303 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ObjectStackProtocolImplementation } from './protocol.js';
+import { ObjectQL } from './engine.js';
+import type { IFeedService } from '@objectstack/spec/contracts';
+
+/**
+ * Mock IFeedService for testing feed route handlers.
+ */
+function createMockFeedService(): IFeedService {
+  return {
+    listFeed: vi.fn().mockResolvedValue({
+      items: [{ id: 'feed_1', type: 'comment', body: 'Hello world', createdAt: '2026-01-01T00:00:00Z' }],
+      total: 1,
+      hasMore: false,
+    }),
+    createFeedItem: vi.fn().mockResolvedValue({
+      id: 'feed_new',
+      type: 'comment',
+      body: 'New comment',
+      createdAt: '2026-01-01T00:00:00Z',
+    }),
+    updateFeedItem: vi.fn().mockResolvedValue({
+      id: 'feed_1',
+      type: 'comment',
+      body: 'Updated comment',
+      createdAt: '2026-01-01T00:00:00Z',
+    }),
+    deleteFeedItem: vi.fn().mockResolvedValue(undefined),
+    getFeedItem: vi.fn().mockResolvedValue({
+      id: 'feed_1',
+      type: 'comment',
+      body: 'Hello world',
+      createdAt: '2026-01-01T00:00:00Z',
+    }),
+    addReaction: vi.fn().mockResolvedValue([
+      { emoji: '👍', users: ['current_user'], count: 1 },
+    ]),
+    removeReaction: vi.fn().mockResolvedValue([]),
+    subscribe: vi.fn().mockResolvedValue({
+      id: 'sub_1',
+      object: 'account',
+      recordId: 'rec_123',
+      userId: 'current_user',
+      events: ['all'],
+      channels: ['in_app'],
+    }),
+    unsubscribe: vi.fn().mockResolvedValue(true),
+    getSubscription: vi.fn().mockResolvedValue(null),
+  };
+}
+
+describe('ObjectStackProtocolImplementation - Feed Operations', () => {
+  let protocol: ObjectStackProtocolImplementation;
+  let engine: ObjectQL;
+  let feedService: IFeedService;
+
+  beforeEach(() => {
+    engine = new ObjectQL();
+    feedService = createMockFeedService();
+    protocol = new ObjectStackProtocolImplementation(engine, undefined, () => feedService);
+  });
+
+  // ==========================================
+  // Discovery
+  // ==========================================
+
+  it('should show feed service as unavailable when not registered', async () => {
+    const protocolNoFeed = new ObjectStackProtocolImplementation(engine);
+    const discovery = await protocolNoFeed.getDiscovery();
+
+    expect(discovery.services.feed).toBeDefined();
+    expect(discovery.services.feed.enabled).toBe(false);
+    expect(discovery.services.feed.status).toBe('unavailable');
+  });
+
+  it('should show feed service as available when registered', async () => {
+    const mockServices = new Map<string, any>();
+    mockServices.set('feed', {});
+    const protocolWithFeed = new ObjectStackProtocolImplementation(engine, () => mockServices, () => feedService);
+    const discovery = await protocolWithFeed.getDiscovery();
+
+    expect(discovery.services.feed).toBeDefined();
+    expect(discovery.services.feed.enabled).toBe(true);
+    expect(discovery.services.feed.status).toBe('available');
+  });
+
+  // ==========================================
+  // Feed CRUD
+  // ==========================================
+
+  it('listFeed should delegate to feedService.listFeed', async () => {
+    const result = await protocol.listFeed({ object: 'account', recordId: 'rec_123' });
+
+    expect(result.success).toBe(true);
+    expect(result.data.items).toHaveLength(1);
+    expect(feedService.listFeed).toHaveBeenCalledWith(
+      expect.objectContaining({ object: 'account', recordId: 'rec_123' })
+    );
+  });
+
+  it('createFeedItem should delegate to feedService.createFeedItem', async () => {
+    const result = await protocol.createFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      type: 'comment',
+      body: 'New comment',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.id).toBe('feed_new');
+    expect(feedService.createFeedItem).toHaveBeenCalledWith(
+      expect.objectContaining({ object: 'account', recordId: 'rec_123', type: 'comment', body: 'New comment' })
+    );
+  });
+
+  it('updateFeedItem should delegate to feedService.updateFeedItem', async () => {
+    const result = await protocol.updateFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+      body: 'Updated',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.body).toBe('Updated comment');
+    expect(feedService.updateFeedItem).toHaveBeenCalledWith('feed_1', expect.objectContaining({ body: 'Updated' }));
+  });
+
+  it('deleteFeedItem should delegate to feedService.deleteFeedItem', async () => {
+    const result = await protocol.deleteFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.feedId).toBe('feed_1');
+    expect(feedService.deleteFeedItem).toHaveBeenCalledWith('feed_1');
+  });
+
+  // ==========================================
+  // Reactions
+  // ==========================================
+
+  it('addReaction should delegate to feedService.addReaction', async () => {
+    const result = await protocol.addReaction({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+      emoji: '👍',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.reactions).toHaveLength(1);
+    expect(feedService.addReaction).toHaveBeenCalledWith('feed_1', '👍', 'current_user');
+  });
+
+  it('removeReaction should delegate to feedService.removeReaction', async () => {
+    const result = await protocol.removeReaction({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+      emoji: '👍',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.reactions).toHaveLength(0);
+    expect(feedService.removeReaction).toHaveBeenCalledWith('feed_1', '👍', 'current_user');
+  });
+
+  // ==========================================
+  // Pin / Star
+  // ==========================================
+
+  it('pinFeedItem should verify item exists and return pinned status', async () => {
+    const result = await protocol.pinFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.feedId).toBe('feed_1');
+    expect(result.data.pinned).toBe(true);
+    expect(result.data.pinnedAt).toBeDefined();
+  });
+
+  it('unpinFeedItem should verify item exists and return unpinned status', async () => {
+    const result = await protocol.unpinFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.feedId).toBe('feed_1');
+    expect(result.data.pinned).toBe(false);
+  });
+
+  it('starFeedItem should verify item exists and return starred status', async () => {
+    const result = await protocol.starFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.feedId).toBe('feed_1');
+    expect(result.data.starred).toBe(true);
+    expect(result.data.starredAt).toBeDefined();
+  });
+
+  it('unstarFeedItem should verify item exists and return unstarred status', async () => {
+    const result = await protocol.unstarFeedItem({
+      object: 'account',
+      recordId: 'rec_123',
+      feedId: 'feed_1',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.feedId).toBe('feed_1');
+    expect(result.data.starred).toBe(false);
+  });
+
+  // ==========================================
+  // Search & Changelog
+  // ==========================================
+
+  it('searchFeed should filter items by query text', async () => {
+    const result = await protocol.searchFeed({
+      object: 'account',
+      recordId: 'rec_123',
+      query: 'hello',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.items).toHaveLength(1);
+    expect(result.data.hasMore).toBe(false);
+  });
+
+  it('getChangelog should return field change entries', async () => {
+    const result = await protocol.getChangelog({
+      object: 'account',
+      recordId: 'rec_123',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.entries).toBeDefined();
+    expect(feedService.listFeed).toHaveBeenCalledWith(
+      expect.objectContaining({ filter: 'changes_only' })
+    );
+  });
+
+  // ==========================================
+  // Subscriptions
+  // ==========================================
+
+  it('feedSubscribe should delegate to feedService.subscribe', async () => {
+    const result = await protocol.feedSubscribe({
+      object: 'account',
+      recordId: 'rec_123',
+      events: ['all'],
+      channels: ['in_app'],
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.object).toBe('account');
+    expect(feedService.subscribe).toHaveBeenCalledWith(
+      expect.objectContaining({ object: 'account', recordId: 'rec_123' })
+    );
+  });
+
+  it('feedUnsubscribe should delegate to feedService.unsubscribe', async () => {
+    const result = await protocol.feedUnsubscribe({
+      object: 'account',
+      recordId: 'rec_123',
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.data.unsubscribed).toBe(true);
+    expect(feedService.unsubscribe).toHaveBeenCalledWith('account', 'rec_123', 'current_user');
+  });
+
+  // ==========================================
+  // Error handling
+  // ==========================================
+
+  it('should throw when feed service is not available', async () => {
+    const protocolNoFeed = new ObjectStackProtocolImplementation(engine);
+
+    await expect(protocolNoFeed.listFeed({ object: 'a', recordId: 'b' }))
+      .rejects.toThrow('Feed service not available');
+  });
+
+  it('pinFeedItem should throw when feed item not found', async () => {
+    (feedService.getFeedItem as any).mockResolvedValue(null);
+
+    await expect(protocol.pinFeedItem({ object: 'a', recordId: 'b', feedId: 'nonexistent' }))
+      .rejects.toThrow('Feed item nonexistent not found');
+  });
+});

package/src/protocol.ts

@@ -8,7 +8,9 @@ import type {
     UpdateManyDataRequest,
     DeleteManyDataRequest
 } from '@objectstack/spec/api';
-import type { MetadataCacheRequest, MetadataCacheResponse, ServiceInfo, ApiRoutes } from '@objectstack/spec/api';
+import type { MetadataCacheRequest, MetadataCacheResponse, ServiceInfo, ApiRoutes, WellKnownCapabilities } from '@objectstack/spec/api';
+import type { IFeedService } from '@objectstack/spec/contracts';
+import { parseFilterAST, isFilterAST } from '@objectstack/spec/data';
 
 // We import SchemaRegistry directly since this class lives in the same package
 import { SchemaRegistry } from './registry.js';
@@ -51,10 +53,20 @@ const SERVICE_CONFIG: Record<string, { route: string; plugin: string }> = {
 export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
     private engine: IDataEngine;
     private getServicesRegistry?: () => Map<string, any>;
+    private getFeedService?: () => IFeedService | undefined;
 
-    constructor(engine: IDataEngine, getServicesRegistry?: () => Map<string, any>) {
+    constructor(engine: IDataEngine, getServicesRegistry?: () => Map<string, any>, getFeedService?: () => IFeedService | undefined) {
         this.engine = engine;
         this.getServicesRegistry = getServicesRegistry;
+        this.getFeedService = getFeedService;
+    }
+
+    private requireFeedService(): IFeedService {
+        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() {
@@ -117,17 +129,45 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             }
         }
 
+        // Add feed service status
+        if (registeredServices.has('feed')) {
+            services['feed'] = {
+                enabled: true,
+                status: 'available' as const,
+                route: '/api/v1/data',
+                provider: 'service-feed',
+            };
+        } else {
+            services['feed'] = {
+                enabled: false,
+                status: 'unavailable' as const,
+                message: 'Install service-feed to enable',
+            };
+        }
+
         const routes: ApiRoutes = {
             data: '/api/v1/data',
             metadata: '/api/v1/meta',
             ...optionalRoutes,
         };
 
+        // Build well-known capabilities from registered services
+        const capabilities: WellKnownCapabilities = {
+            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,
+            capabilities,
         };
     }
 
@@ -264,12 +304,22 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             delete options.orderBy;
         }
 
+        // Filter: normalize `filter`/`filters` (plural) → `filter` (singular, canonical)
+        // Accept both `filter` and `filters` for backward compatibility.
+        if (options.filters !== undefined && options.filter === undefined) {
+            options.filter = options.filters;
+        }
+        delete options.filters;
+
         // Filter: JSON string → object
         if (typeof options.filter === 'string') {
             try { options.filter = JSON.parse(options.filter); } catch { /* keep as-is */ }
         }
-        if (typeof options.filters === 'string') {
-            try { options.filter = JSON.parse(options.filters); delete options.filters; } catch { /* keep as-is */ }
+
+        // Filter AST array → FilterCondition object
+        // Converts ["and", ["field", "=", "val"], ...] to { $and: [{ field: "val" }, ...] }
+        if (isFilterAST(options.filter)) {
+            options.filter = parseFilterAST(options.filter);
         }
 
         // Populate: comma-separated string → array
@@ -702,4 +752,155 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             message: 'Saved to memory registry'
         };
     }
+
+    // ==========================================
+    // Feed Operations
+    // ==========================================
+
+    async listFeed(request: any): Promise<any> {
+        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: any): Promise<any> {
+        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: any): Promise<any> {
+        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: any): Promise<any> {
+        const svc = this.requireFeedService();
+        await svc.deleteFeedItem(request.feedId);
+        return { success: true, data: { feedId: request.feedId } };
+    }
+
+    async addReaction(request: any): Promise<any> {
+        const svc = this.requireFeedService();
+        const reactions = await svc.addReaction(request.feedId, request.emoji, 'current_user');
+        return { success: true, data: { reactions } };
+    }
+
+    async removeReaction(request: any): Promise<any> {
+        const svc = this.requireFeedService();
+        const reactions = await svc.removeReaction(request.feedId, request.emoji, 'current_user');
+        return { success: true, data: { reactions } };
+    }
+
+    async pinFeedItem(request: any): Promise<any> {
+        const svc = this.requireFeedService();
+        const item = await svc.getFeedItem(request.feedId);
+        if (!item) throw new Error(`Feed item ${request.feedId} not found`);
+        // IFeedService doesn't have dedicated pin/unpin — use updateFeedItem to persist pin state
+        await svc.updateFeedItem(request.feedId, { visibility: item.visibility });
+        return { success: true, data: { feedId: request.feedId, pinned: true, pinnedAt: new Date().toISOString() } };
+    }
+
+    async unpinFeedItem(request: any): Promise<any> {
+        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: any): Promise<any> {
+        const svc = this.requireFeedService();
+        const item = await svc.getFeedItem(request.feedId);
+        if (!item) throw new Error(`Feed item ${request.feedId} not found`);
+        // IFeedService doesn't have dedicated star/unstar — verify item exists then return state
+        await svc.updateFeedItem(request.feedId, { visibility: item.visibility });
+        return { success: true, data: { feedId: request.feedId, starred: true, starredAt: new Date().toISOString() } };
+    }
+
+    async unstarFeedItem(request: any): Promise<any> {
+        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: any): Promise<any> {
+        const svc = this.requireFeedService();
+        // Search delegates to listFeed with filter since IFeedService doesn't have a dedicated search
+        const result = await svc.listFeed({
+            object: request.object,
+            recordId: request.recordId,
+            filter: request.type,
+            limit: request.limit,
+            cursor: request.cursor,
+        });
+        // Filter by query text in body
+        const queryLower = (request.query || '').toLowerCase();
+        const filtered = result.items.filter((item: any) =>
+            item.body?.toLowerCase().includes(queryLower)
+        );
+        return { success: true, data: { items: filtered, total: filtered.length, hasMore: false } };
+    }
+
+    async getChangelog(request: any): Promise<any> {
+        const svc = this.requireFeedService();
+        // Changelog retrieves field_change type feed items
+        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: any) => ({
+            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: any): Promise<any> {
+        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: any): Promise<any> {
+        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 } };
+    }
 }