@ossy/workspaces 3.11.0 → 3.11.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ossy/workspaces",
   "description": "Workspaces feature package - create, select, and manage workspaces, users, and invitations",
-  "version": "3.11.0",
+  "version": "3.11.1",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -50,5 +50,5 @@
     "/src",
     "README.md"
   ],
-  "gitHead": "53ff8456920e09151c9d88df4a6c3ee958d811eb"
+  "gitHead": "f279de3535b6bc76631cbc6b943dae8f92a1565f"
 }

package/src/workspaces.queries.js

@@ -4,42 +4,78 @@ import { WorkspaceSchema } from './schema-ids.js'
 
 const log = createLogger('workspaces')
 
+/**
+ * Membership events that mean the user belongs to a workspace.
+ * Kept narrow so the list query never scans every workspace stream.
+ */
+const MEMBERSHIP_EVENTS = ['Created', 'UserInvitationAccepted']
+
 export class WorkspacesQueries {
+  /**
+   * Minified `{ id, name }[]` for workspaces the user created or joined.
+   *
+   * Pipeline shape (perf-critical for select-workspace):
+   * 1. `$match` only this user's membership events (not every workspace event)
+   * 2. `$group` by workspace id (name when the user is the creator)
+   * 3. `$lookup` the workspace `Created` event for name when the user only joined
+   */
   static getAllByUserIncluded (userId) {
     log.info('[WorkspacesQueries] getAllByUserIncluded()')
+    if (!userId) return Promise.resolve([])
+
     return EventStore.Aggregate([
-      { $match: { type: WorkspaceSchema.workspace, resourceId: { $exists: true } } },
-      { $group: { _id: '$resourceId', events: { $push: '$$ROOT' } } },
       {
         $match: {
-          $or: [
-            { 'events.createdBy': userId },
-            { 'events.event': 'UserInvitationAccepted', 'events.createdBy': userId },
-          ],
-          'events.event': { $in: ['Created', 'UserInvitationAccepted'] },
+          type: WorkspaceSchema.workspace,
+          createdBy: userId,
+          event: { $in: MEMBERSHIP_EVENTS },
         },
       },
       {
-        $project: {
-          id: '$_id',
+        $group: {
+          _id: '$resourceId',
           name: {
-            $let: {
-              vars: {
-                created: {
-                  $arrayElemAt: [
-                    {
-                      $filter: {
-                        input: '$events',
-                        as: 'e',
-                        cond: { $eq: ['$$e.event', 'Created'] },
-                      },
-                    },
-                    0,
+            $max: {
+              $cond: [
+                { $eq: ['$event', 'Created'] },
+                '$payload.name',
+                null,
+              ],
+            },
+          },
+        },
+      },
+      {
+        $lookup: {
+          from: 'eventstore',
+          let: { workspaceId: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: ['$resourceId', '$$workspaceId'] },
+                    { $eq: ['$type', WorkspaceSchema.workspace] },
+                    { $eq: ['$event', 'Created'] },
                   ],
                 },
               },
-              in: '$$created.payload.name',
             },
+            { $limit: 1 },
+            { $project: { _id: 0, name: '$payload.name' } },
+          ],
+          as: '_created',
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          id: '$_id',
+          name: {
+            $ifNull: [
+              '$name',
+              { $arrayElemAt: ['$_created.name', 0] },
+            ],
           },
         },
       },

package/src/workspaces.queries.spec.js

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals'
+
+const aggregateMock = jest.fn()
+
+jest.unstable_mockModule('@ossy/event-store', () => ({
+  EventStore: {
+    Aggregate: aggregateMock,
+  },
+}))
+
+jest.unstable_mockModule('@ossy/observability', () => ({
+  createLogger: () => ({
+    info: () => {},
+    error: () => {},
+    warn: () => {},
+    debug: () => {},
+  }),
+}))
+
+const { WorkspacesQueries } = await import('./workspaces.queries.js')
+const { WorkspaceSchema } = await import('./schema-ids.js')
+
+describe('WorkspacesQueries.getAllByUserIncluded', () => {
+  beforeEach(() => {
+    aggregateMock.mockReset()
+  })
+
+  it('returns [] without hitting Mongo when userId is missing', async () => {
+    await expect(WorkspacesQueries.getAllByUserIncluded()).resolves.toEqual([])
+    await expect(WorkspacesQueries.getAllByUserIncluded(null)).resolves.toEqual([])
+    expect(aggregateMock).not.toHaveBeenCalled()
+  })
+
+  it('scopes the aggregation to this user membership events only', async () => {
+    aggregateMock.mockResolvedValue([{ id: 'ws-1', name: 'Acme' }])
+
+    await expect(WorkspacesQueries.getAllByUserIncluded('user-1')).resolves.toEqual([
+      { id: 'ws-1', name: 'Acme' },
+    ])
+
+    expect(aggregateMock).toHaveBeenCalledTimes(1)
+    const [pipeline] = aggregateMock.mock.calls[0]
+    expect(pipeline[0]).toEqual({
+      $match: {
+        type: WorkspaceSchema.workspace,
+        createdBy: 'user-1',
+        event: { $in: ['Created', 'UserInvitationAccepted'] },
+      },
+    })
+    expect(pipeline.some(stage => stage.$lookup?.from === 'eventstore')).toBe(true)
+    // Must not scan every workspace stream then filter
+    expect(JSON.stringify(pipeline[0])).not.toContain('events.createdBy')
+  })
+
+  it('returns [] when the aggregation rejects', async () => {
+    aggregateMock.mockRejectedValue(new Error('mongo down'))
+    await expect(WorkspacesQueries.getAllByUserIncluded('user-1')).resolves.toEqual([])
+  })
+})