@ossy/workspaces 1.12.0 → 1.13.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ossy/workspaces",
   "description": "Workspaces feature package — create, select, and manage workspaces, users, and invitations",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -9,6 +9,9 @@
     ".": "./src/index.js",
     "./workspace-invitation.email.jsx": "./src/workspace-invitation.email.jsx"
   },
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --verbose"
+  },
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "ossy": {
@@ -20,6 +23,12 @@
     "@ossy/sdk-react": ">=1.0.0",
     "react": ">=19.0.0 <20.0.0"
   },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "@ossy/platform": "^1.35.0",
+    "casual": "^1.6.2",
+    "jest": "^30.2.0"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -28,5 +37,5 @@
     "/src",
     "README.md"
   ],
-  "gitHead": "c6697078268867d88553ca0bac08faad5cea1546"
+  "gitHead": "24df2bde0d5d8794c5a82b9e802a2594ca73a5d9"
 }

package/src/sync-workspace-membership.task.js

@@ -0,0 +1,40 @@
+import { Aggregate } from '@ossy/event-store'
+import { User, UsersEvents } from '@ossy/users'
+
+export const metadata = {
+  id: 'sync-workspace-membership',
+  triggers: [
+    { aggregateType: 'Workspace', event: 'Created' },
+    { aggregateType: 'Workspace', event: 'UserInvitationAccepted' },
+    { aggregateType: 'Workspace', event: 'UserRemoved' },
+  ],
+}
+
+export async function run ({ event, sdk }) {
+  const workspaceId = event.aggregateId
+
+  if (event.type === 'UserRemoved') {
+    const userId = event.payload.userId
+
+    if (sdk) {
+      await sdk.users.removeWorkspace({ userId, workspaceId })
+      return
+    }
+
+    await Aggregate.Of(User, userId)
+      .then(Aggregate.Add(UsersEvents.WorkspaceLeft({ workspaceId, createdBy: userId })))
+      .then(Aggregate.Save())
+    return
+  }
+
+  const userId = event.createdBy
+
+  if (sdk) {
+    await sdk.users.addWorkspace({ userId, workspaceId, createdBy: userId })
+    return
+  }
+
+  await Aggregate.Of(User, userId)
+    .then(Aggregate.Add(UsersEvents.WorkspaceJoined({ workspaceId, createdBy: userId })))
+    .then(Aggregate.Save())
+}

package/src/workspaces.spec.js

@@ -0,0 +1,258 @@
+import casual from 'casual'
+import { TestUtil } from '@ossy/platform/test'
+
+function workspaceHeaders(userToken, workspaceId) {
+  return {
+    'Content-Type': 'application/json',
+    Authorization: userToken,
+    workspaceId,
+  }
+}
+
+describe('[/workspaces][POST]', () => {
+
+  TestUtil.AssertAuthenticationNeeded({
+    endpoint: '/workspaces',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+  })
+
+  describe('given a workspace name', () => {
+    it('must return OK 200 together with the newly created workspace and create a WorkspaceCreatedEvent', async () => {
+      const user = await TestUtil.GetAuthenticatedTestUser()
+      const workspaceName = casual.word
+
+      const response = await TestUtil.MakeRequest({
+        endpoint: '/workspaces',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+        body: JSON.stringify({ name: workspaceName }),
+      })
+
+      const body = await response.json()
+
+      const workspaceCreatedEvent = await TestUtil.GetEvent({
+        aggregateType: 'Workspace',
+        type: 'Created',
+        createdBy: user.id,
+        'payload.name': workspaceName
+      })
+
+      expect(!!workspaceCreatedEvent).toEqual(true)
+      expect(response.status).toEqual(200)
+      expect(response.headers.get('Content-Type').includes('application/json')).toEqual(true)
+      expect(body.id).toEqual(workspaceCreatedEvent.aggregateId)
+      expect(body.name).toEqual(workspaceName)
+      expect(body.createdBy).toEqual(user.id)
+      expect(body.created).toEqual(workspaceCreatedEvent.created)
+      expect(body.apiTokens).toEqual([])
+      expect(Array.isArray(body.resourceTemplates)).toBe(true)
+      expect(body.resourceTemplates.length).toEqual(0)
+    })
+  })
+
+})
+
+describe('[/workspaces][GET]', () => {
+
+  TestUtil.AssertAuthenticationNeeded({
+    endpoint: '/workspaces',
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json' },
+  })
+
+  it('must return a minified list of workspaces the user have created', async () => {
+    const user = await TestUtil.GetAuthenticatedTestUser()
+
+    const workspace = await TestUtil.MakeRequest({
+      endpoint: '/workspaces',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+      body: JSON.stringify({ name: casual.word }),
+    }).then(response => response.json())
+
+    const response = await TestUtil.MakeRequest({
+      endpoint: '/workspaces',
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+    })
+
+    const responseBody = await response.json()
+
+    expect(response.status).toEqual(200)
+    expect(responseBody).toEqual([{
+      name: workspace.name,
+      id: workspace.id
+    }])
+
+  })
+
+})
+
+describe('[/workspaces/:workspaceId][GET]', () => {
+
+  TestUtil.AssertAuthenticationNeeded({
+    endpoint: '/workspaces/123',
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json' },
+  })
+
+  it('must return the requested workspace', async () => {
+    const user = await TestUtil.GetAuthenticatedTestUser()
+
+    const workspace = await TestUtil.MakeRequest({
+      endpoint: '/workspaces',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+      body: JSON.stringify({ name: casual.word }),
+    }).then(response => response.json())
+
+    const response = await TestUtil.MakeRequest({
+      endpoint: `/workspaces/${workspace.id}`,
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+    })
+
+    const responseBody = await response.json()
+
+    expect(response.status).toEqual(200)
+    expect(responseBody).toEqual(workspace)
+
+  })
+
+})
+
+describe('[/resource-templates][POST]', () => {
+
+  TestUtil.AssertAuthenticationNeeded({
+    endpoint: '/resource-templates',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'workspaceId': 'ws-test' },
+  })
+
+  it('must return the saved templates and create a ResourceTemplatesImported event', async () => {
+    const user = await TestUtil.GetAuthenticatedTestUser()
+
+    const workspace = await TestUtil.MakeRequest({
+      endpoint: '/workspaces',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+      body: JSON.stringify({ name: casual.word }),
+    }).then(response => response.json())
+
+    const imported = [
+      {
+        id: 'test/custom-foo',
+        name: 'Foo',
+        fields: [{ name: 'title', type: 'text' }],
+      },
+    ]
+
+    const response = await TestUtil.MakeRequest({
+      endpoint: '/resource-templates',
+      method: 'POST',
+      headers: workspaceHeaders(user.token, workspace.id),
+      body: JSON.stringify(imported)
+    })
+
+    const responseBody = await response.json()
+
+    const resourceTemplatesImportedEvent = await TestUtil.GetEvent({
+      aggregateType: 'Workspace',
+      type: 'ResourceTemplatesImported',
+      createdBy: user.id,
+      'payload.templates': imported
+    })
+
+    expect(response.status).toEqual(200)
+    expect(responseBody).toEqual(imported)
+    expect(!!resourceTemplatesImportedEvent).toEqual(true)
+
+  })
+
+})
+
+describe('[/resource-templates][GET]', () => {
+
+  TestUtil.AssertAuthenticationNeeded({
+    endpoint: '/resource-templates',
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json', 'workspaceId': 'ws-test' },
+  })
+
+  it('must return the saved templates event', async () => {
+    const user = await TestUtil.GetAuthenticatedTestUser()
+
+    const workspace = await TestUtil.MakeRequest({
+      endpoint: '/workspaces',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+      body: JSON.stringify({ name: casual.word }),
+    }).then(response => response.json())
+
+    const imported = [
+      {
+        id: 'test/custom-bar',
+        name: 'Bar',
+        fields: [{ name: 'title', type: 'text' }],
+      },
+    ]
+
+    const response = await TestUtil.MakeRequest({
+      endpoint: '/resource-templates',
+      method: 'POST',
+      headers: workspaceHeaders(user.token, workspace.id),
+      body: JSON.stringify(imported)
+    })
+
+    const responseBody = await response.json()
+
+    expect(response.status).toEqual(200)
+    expect(responseBody).toEqual(imported)
+
+  })
+
+})
+
+describe('[/tokens][POST]', () => {
+
+  TestUtil.AssertAuthenticationNeeded({
+    endpoint: '/tokens',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'workspaceId': 'ws-test' },
+  })
+
+  it('must return an api token and create an ApiTokenCreated event', async () => {
+    const user = await TestUtil.GetAuthenticatedTestUser()
+
+    const workspace = await TestUtil.MakeRequest({
+      endpoint: '/workspaces',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': user.token },
+      body: JSON.stringify({ name: casual.word }),
+    }).then(response => response.json())
+
+    const response = await TestUtil.MakeRequest({
+      endpoint: '/tokens',
+      method: 'POST',
+      headers: workspaceHeaders(user.token, workspace.id),
+      body: JSON.stringify({ description: 'Api token for GitHub Actions' })
+    })
+
+    const responseBody = await response.json()
+    const tokenPayload = JSON.parse(Buffer.from(responseBody.token.split('.')[1], 'base64').toString())
+
+    expect(response.status).toEqual(200)
+    expect(responseBody).toEqual(expect.objectContaining({
+      id: expect.any(String),
+      token: expect.any(String)
+    }))
+    expect(tokenPayload).toEqual(expect.objectContaining({
+      workspaceId: workspace.id,
+      exp: expect.any(Number),
+      iat: expect.any(Number)
+    }))
+
+  })
+
+})