@ossy/workspaces 1.11.0 → 1.13.0

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@ossy/workspaces",
   "description": "Workspaces feature package — create, select, and manage workspaces, users, and invitations",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./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",
@@ -19,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"
@@ -27,5 +37,5 @@
     "/src",
     "README.md"
   ],
-  "gitHead": "46cdd391ec01ea9210543ee7b14661f77079a7e7"
+  "gitHead": "24df2bde0d5d8794c5a82b9e802a2594ca73a5d9"
 }

package/src/accept-invitation.action.js

@@ -0,0 +1,85 @@
+import jwt from 'jsonwebtoken'
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+import { User, UsersEvents } from '@ossy/users'
+import { Token, TokenEvents } from '@ossy/tokens'
+import { ConfigService } from '@ossy/platform'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('workspaces/accept-invitation')
+
+function verifyToken(token) {
+  return new Promise((resolve, reject) => {
+    if (!token) return reject(new Error('No token'))
+    jwt.verify(token, ConfigService.TokenSecret, { algorithms: ['HS256'] }, (err, payload) => {
+      if (err) return reject(err)
+      resolve(payload)
+    })
+  })
+}
+
+export const id = 'workspaces/accept-invitation'
+export const access = 'public'
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const verificationToken = payload?.token ?? req?.query?.token
+
+  const { aud: tokenWorkspaceId, sub: email } = await verifyToken(verificationToken)
+    .catch(() => { throw Object.assign(new Error('Invalid token'), { status: 401 }) })
+
+  const resolvedWorkspaceId = tokenWorkspaceId ?? workspaceId
+  const workspace = await Aggregate.Of(Workspace, resolvedWorkspaceId).then(Aggregate.View())
+
+  if (!email) throw Object.assign(new Error('No email found in token payload'), { status: 401 })
+
+  const existingUser = await Aggregate.Collection.findOne({ type: 'User', 'state.email': email }).then(agg => agg?.state)
+
+  if (existingUser && workspace.users.includes(existingUser.id)) {
+    throw Object.assign(new Error('User already in workspace'), { status: 400 })
+  }
+
+  let userId
+  let signInToken
+  let signInExpiresAt
+
+  if (existingUser) {
+    userId = existingUser.id
+    const signInExpiresIn = ConfigService.TokenValidity
+    signInExpiresAt = Date.now() + signInExpiresIn * 1000
+    signInToken = jwt.sign({ sub: userId, type: 'WebAuth' }, ConfigService.TokenSecret, { expiresIn: signInExpiresIn })
+    const signInEvent = TokenEvents.Created({
+      type: 'WebAuth',
+      subject: userId,
+      createdBy: userId,
+      token: signInToken,
+      expiresAt: signInExpiresAt,
+    })
+    const userInvitationAccepted = WorkspacesEvents.UserInvitationAccepted({ email, createdBy: userId })
+    await Promise.all([
+      Aggregate.Of(Token, signInEvent),
+      Aggregate.Of(Workspace, resolvedWorkspaceId).then(Aggregate.Add(userInvitationAccepted)),
+    ])
+  } else {
+    const signUpEvent = UsersEvents.SignedUp({ email })
+    userId = signUpEvent.createdBy
+    const signInExpiresIn = ConfigService.TokenValidity
+    signInExpiresAt = Date.now() + signInExpiresIn * 1000
+    signInToken = jwt.sign({ sub: userId, type: 'WebAuth' }, ConfigService.TokenSecret, { expiresIn: signInExpiresIn })
+    const signInEvent = TokenEvents.Created({
+      type: 'WebAuth',
+      subject: userId,
+      createdBy: userId,
+      token: signInToken,
+      expiresAt: signInExpiresAt,
+    })
+    const userInvitationAccepted = WorkspacesEvents.UserInvitationAccepted({ email, createdBy: userId })
+    await Promise.all([
+      Aggregate.Of(User, signUpEvent),
+      Aggregate.Of(Token, signInEvent),
+      Aggregate.Of(Workspace, resolvedWorkspaceId).then(Aggregate.Add(userInvitationAccepted)),
+    ])
+  }
+
+  return { authToken: signInToken, authExpiresAt: signInExpiresAt }
+}

package/src/create-api-token.action.js

@@ -0,0 +1,17 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+
+export const id = 'workspaces/create-api-token'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const createdBy = payload?.userId ?? req?.userId
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const description = payload?.description
+
+  const event = WorkspacesEvents.ApiTokenCreated({ createdBy, workspaceId, description })
+
+  const aggregate = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.Add(event))
+  const last = aggregate.events[aggregate.events.length - 1]
+  return { id: last.id, token: event.payload.token }
+}

package/src/create.action.js

@@ -0,0 +1,30 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+import { ConfigService } from '@ossy/platform'
+
+export const id = 'workspaces/create'
+export const access = 'authenticated'
+
+export async function run({ payload, req }) {
+  const createdBy = payload?.userId ?? req?.userId
+  const name = (payload?.name ?? req?.body?.name)?.trim?.()
+
+  if (!name || typeof name !== 'string') {
+    throw Object.assign(new Error('Invalid name'), { status: 400 })
+  }
+
+  const createdEvent = WorkspacesEvents.Created({ createdBy, name })
+  const botUserInvitedEvent = WorkspacesEvents.UserInvited({
+    createdBy: ConfigService.BotUserId,
+    email: ConfigService.BotUserEmail,
+  })
+  const botUserAcceptedEvent = WorkspacesEvents.UserInvitationAccepted({
+    createdBy: ConfigService.BotUserId,
+    email: ConfigService.BotUserEmail,
+  })
+
+  return Aggregate.Of(Workspace, createdEvent)
+    .then(Aggregate.Add(botUserInvitedEvent))
+    .then(Aggregate.Add(botUserAcceptedEvent))
+    .then(Aggregate.View())
+}

package/src/current.api.js

@@ -0,0 +1,30 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.current',
+  path: '/api/v0/workspaces/current',
+}
+
+export default async function handle(req, res) {
+  if (req.method !== 'GET') {
+    res.setHeader('Allow', 'GET')
+    res.status(405).json({ error: 'Method Not Allowed' })
+    return
+  }
+
+  const workspaceId = req.workspaceId || req.user?.workspaces?.[0]
+  if (!workspaceId) {
+    res.status(404).json(null)
+    return
+  }
+
+  try {
+    const workspace = await ActionService.invoke('workspaces/get', {
+      payload: { workspaceId },
+      req: { ...req, workspaceId },
+    })
+    res.json(workspace)
+  } catch (err) {
+    res.status(err?.status ?? 500).json({ error: err?.message })
+  }
+}

package/src/disable-service.action.js

@@ -0,0 +1,28 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+
+export const id = 'workspaces/disable-service'
+export const access = 'workspace'
+
+const AVAILABLE_SERVICES = [
+  '@ossy/tasks/visual-content-descriptors',
+  '@ossy/tasks/resize-common-web',
+  '@ossy/resumes',
+  '@ossy/consultancy',
+  '@ossy/apps',
+  '@ossy/domains',
+]
+
+export async function run({ payload, req }) {
+  const createdBy = payload?.userId ?? req?.userId
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const service = payload?.service
+
+  if (!AVAILABLE_SERVICES.includes(service)) {
+    throw Object.assign(new Error(`Service ${service} is not available`), { status: 400 })
+  }
+
+  const event = WorkspacesEvents.ServiceDisabled({ createdBy, service })
+  await Aggregate.Of(Workspace, workspaceId).then(Aggregate.Add(event))
+  return null
+}

package/src/enable-service.action.js

@@ -0,0 +1,28 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+
+export const id = 'workspaces/enable-service'
+export const access = 'workspace'
+
+const AVAILABLE_SERVICES = [
+  '@ossy/tasks/visual-content-descriptors',
+  '@ossy/tasks/resize-common-web',
+  '@ossy/resumes',
+  '@ossy/consultancy',
+  '@ossy/apps',
+  '@ossy/domains',
+]
+
+export async function run({ payload, req }) {
+  const createdBy = payload?.userId ?? req?.userId
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const service = payload?.service ?? payload
+
+  if (!AVAILABLE_SERVICES.includes(service)) {
+    throw Object.assign(new Error(`Service ${service} is not available`), { status: 400 })
+  }
+
+  const event = WorkspacesEvents.ServiceEnabled({ createdBy, service })
+  await Aggregate.Of(Workspace, workspaceId).then(Aggregate.Add(event))
+  return null
+}

package/src/get-api-tokens.action.js

@@ -0,0 +1,11 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace } from '@ossy/workspaces'
+
+export const id = 'workspaces/get-api-tokens'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+  return workspace.apiTokens
+}

package/src/get-invitations.action.js

@@ -0,0 +1,11 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace } from '@ossy/workspaces'
+
+export const id = 'workspaces/get-invitations'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+  return workspace.invitations
+}

package/src/get-resource-templates.action.js

@@ -0,0 +1,19 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace } from '@ossy/workspaces'
+import { getSystemResourceTemplates } from '@ossy/platform'
+
+export const id = 'workspaces/get-resource-templates'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+  const systemTemplates = getSystemResourceTemplates()
+  const workspaceTemplates = workspace.resourceTemplates || []
+  const workspaceIds = new Set(workspaceTemplates.map(t => t.id))
+  return [
+    ...systemTemplates.filter(t => !workspaceIds.has(t.id)),
+    ...workspaceTemplates,
+  ]
+}

package/src/get-users.action.js

@@ -0,0 +1,14 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace } from '@ossy/workspaces'
+import { User } from '@ossy/users'
+
+export const id = 'workspaces/get-users'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+  return Promise.all(
+    workspace.users.map(userId => Aggregate.Of(User, userId).then(Aggregate.View(User.UserForWorkspace)))
+  )
+}

package/src/get.action.js

@@ -0,0 +1,14 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace } from '@ossy/workspaces'
+
+export const id = 'workspaces/get'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  if (!workspaceId) throw Object.assign(new Error('workspaceId is required'), { status: 404 })
+
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+  if (!workspace?.id) throw Object.assign(new Error('Workspace not found'), { status: 404 })
+  return workspace
+}

package/src/import-resource-templates.action.js

@@ -0,0 +1,27 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+import { validateResourceTemplatesForImport } from '@ossy/platform'
+
+export const id = 'workspaces/import-resource-templates'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const userId = payload?.userId ?? req?.userId
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const templates = payload?.templates ?? payload
+
+  if (!Array.isArray(templates)) {
+    throw Object.assign(new Error('templates must be an array'), { status: 400 })
+  }
+
+  const reservedIds = new Set([])
+  const validation = validateResourceTemplatesForImport(templates, reservedIds)
+  if (!validation.ok) {
+    throw Object.assign(new Error(validation.message), { status: 400, type: validation.code })
+  }
+
+  const event = WorkspacesEvents.ResourceTemplatesImported({ createdBy: userId, templates })
+
+  await Aggregate.Of(Workspace, workspaceId).then(Aggregate.Add(event))
+  return event.payload.templates
+}

package/src/invitations.api.js

@@ -0,0 +1,46 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'invitations.root',
+  path: '/api/v0/invitations',
+}
+
+export default async function handle(req, res) {
+  if (req.method === 'POST') {
+    try {
+      await ActionService.invoke('workspaces/invite-user', {
+        payload: {
+          email: req.body,
+          workspaceId: req.workspaceId,
+          userId: req.userId,
+          inviterEmail: req.user?.email,
+        },
+        integrations: req.integrations,
+        req,
+      })
+      res.json('')
+    } catch (err) {
+      res.status(err?.status ?? 400).json(err?.message ?? 'Could not invite user')
+    }
+    return
+  }
+  if (req.method === 'GET') {
+    try {
+      const result = await ActionService.invoke('workspaces/accept-invitation', {
+        payload: { workspaceId: req.workspaceId, token: req.query?.token },
+        req,
+      })
+      res.cookie('auth', result.authToken, {
+        httpOnly: true,
+        signed: true,
+        expires: new Date(result.authExpiresAt),
+      })
+      res.json('')
+    } catch (err) {
+      res.status(err?.status ?? 401).json('')
+    }
+    return
+  }
+  res.setHeader('Allow', 'GET, POST')
+  res.status(405).json({ error: 'Method Not Allowed' })
+}

package/src/invite-user.action.js

@@ -0,0 +1,82 @@
+import jwt from 'jsonwebtoken'
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+import { Token, TokenEvents } from '@ossy/tokens'
+import { EmailRenderer } from '@ossy/email'
+import { ConfigService } from '@ossy/platform'
+import { createLogger } from '@ossy/observability'
+import WorkspaceInvitationEmail, { subject as workspaceInvitationSubject } from './workspace-invitation.email.jsx'
+
+const log = createLogger('workspaces/invite-user')
+
+const isEmailLike = maybeEmail => /.@.+\.../.test(maybeEmail)
+
+function createVerificationToken(workspaceId) {
+  const expiresIn = ConfigService.TokenValidity
+  return jwt.sign({ aud: workspaceId }, ConfigService.TokenSecret, { expiresIn })
+}
+
+export const id = 'workspaces/invite-user'
+export const access = 'workspace'
+
+export async function run({ payload, integrations, req }) {
+  const createdBy = payload?.userId ?? req?.userId
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const email = payload?.email ?? req?.body
+  const inviterEmail = payload?.inviterEmail ?? req?.user?.email
+
+  if (!isEmailLike(email)) {
+    throw Object.assign(new Error('Invalid email'), { status: 400 })
+  }
+
+  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
+
+  const userInvitation = workspace.invitations.find(inv => inv.email === email)
+  if (userInvitation && userInvitation.expiresAt > Date.now()) {
+    throw Object.assign(new Error('User already invited'), { status: 400 })
+  }
+
+  const expiresIn = ConfigService.TokenValidity
+  const expiresAt = Date.now() + expiresIn * 1000
+  const inviteEvent = WorkspacesEvents.UserInvited({ createdBy, email, expiresAt })
+
+  const rawToken = createVerificationToken(workspaceId)
+  const tokenEvent = TokenEvents.Created({
+    type: 'Verification',
+    createdBy,
+    name: 'Workspace Invitation',
+    subject: email,
+    audience: workspace.id,
+    token: rawToken,
+    expiresAt,
+  })
+
+  const existingUser = await Aggregate.Collection.findOne({ type: 'User', 'state.email': email }).then(agg => agg?.state)
+  if (existingUser && workspace.users.includes(existingUser.id)) {
+    throw Object.assign(new Error('User already in workspace'), { status: 400 })
+  }
+
+  await Promise.all([
+    Aggregate.Of(Workspace, workspace.id).then(Aggregate.Add(inviteEvent)),
+    Aggregate.Of(Token, tokenEvent),
+  ])
+
+  const baseUrl = ConfigService.getWebClientBaseUrl(req)
+  const { html, text } = EmailRenderer.render(WorkspaceInvitationEmail, {
+    workspace,
+    verificationToken: rawToken,
+    invitedBy: inviterEmail,
+    baseUrl,
+  })
+
+  const emailClient = integrations?.get?.('email')
+  if (emailClient) {
+    await emailClient.send({ to: email, from: 'noreply@ossy.se', subject: workspaceInvitationSubject, html, text })
+  } else if (ConfigService.BuildEnvironment === 'local') {
+    log.info('-----------YOU GOT MAIL-----------')
+    log.info('Email', { to: email, subject: workspaceInvitationSubject })
+    log.info('----------------------------------')
+  }
+
+  return ''
+}

package/src/item.api.js

@@ -0,0 +1,32 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.item',
+  path: '/api/v0/workspaces/:workspaceId',
+}
+
+export default async function handle(req, res) {
+  if (req.method !== 'GET') {
+    res.setHeader('Allow', 'GET')
+    res.status(405).json({ error: 'Method Not Allowed' })
+    return
+  }
+
+  const pathname = (req.path || new URL(req.originalUrl, 'http://localhost').pathname).replace(/\/+$/, '')
+  const m = pathname.match(/^\/api\/v0\/workspaces\/([^/]+)$/)
+  if (!m || m[1] === 'current') {
+    res.status(404).json('')
+    return
+  }
+
+  const workspaceId = decodeURIComponent(m[1])
+  try {
+    const workspace = await ActionService.invoke('workspaces/get', {
+      payload: { workspaceId },
+      req: { ...req, workspaceId },
+    })
+    res.json(workspace)
+  } catch (err) {
+    res.status(err?.status ?? 500).json({ error: err?.message })
+  }
+}

package/src/list.action.js

@@ -0,0 +1,9 @@
+import { WorkspacesQueries } from './workspaces.queries.js'
+
+export const id = 'workspaces/list'
+export const access = 'authenticated'
+
+export async function run({ payload, req }) {
+  const userId = payload?.userId ?? req?.userId
+  return WorkspacesQueries.getAllByUserIncluded(userId)
+}

package/src/list.api.js

@@ -0,0 +1,35 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.list',
+  path: '/api/v0/workspaces',
+}
+
+export default async function handle(req, res) {
+  if (req.method === 'POST') {
+    try {
+      const workspace = await ActionService.invoke('workspaces/create', {
+        payload: { name: req.body?.name, userId: req.userId },
+        req,
+      })
+      res.json(workspace)
+    } catch (err) {
+      res.status(err?.status ?? 400).json({ error: err?.message })
+    }
+    return
+  }
+  if (req.method === 'GET') {
+    try {
+      const workspaces = await ActionService.invoke('workspaces/list', {
+        payload: { userId: req.userId },
+        req,
+      })
+      res.json(workspaces)
+    } catch (err) {
+      res.status(err?.status ?? 400).json({ error: err?.message })
+    }
+    return
+  }
+  res.setHeader('Allow', 'GET, POST')
+  res.status(405).json({ error: 'Method Not Allowed' })
+}

package/src/members.api.js

@@ -0,0 +1,42 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.members',
+  path: '/api/v0/workspaces/:workspaceId/members/:userId',
+}
+
+export default async function handle(req, res) {
+  if (req.method !== 'DELETE') {
+    res.setHeader('Allow', 'DELETE')
+    res.status(405).json({ error: 'Method Not Allowed' })
+    return
+  }
+
+  const pathname = (req.path || new URL(req.originalUrl, 'http://localhost').pathname).replace(/\/+$/, '')
+  const m = pathname.match(/^\/api\/v0\/workspaces\/([^/]+)\/members\/([^/]+)$/)
+  if (!m) {
+    res.status(404).json('')
+    return
+  }
+
+  const workspaceId = decodeURIComponent(m[1])
+  const memberId = decodeURIComponent(m[2])
+
+  const isMember = Array.isArray(req.user?.workspaces) && req.user.workspaces.includes(workspaceId)
+  const isSelf = req.user?.id === memberId
+
+  if (!isMember && !isSelf) {
+    res.status(403).json({ error: 'Forbidden' })
+    return
+  }
+
+  try {
+    await ActionService.invoke('workspaces/remove-member', {
+      payload: { workspaceId, memberId, userId: req.userId },
+      req,
+    })
+    res.json()
+  } catch (err) {
+    res.status(err?.status ?? 500).json({ error: err?.message })
+  }
+}

package/src/remove-member.action.js

@@ -0,0 +1,17 @@
+import { Aggregate } from '@ossy/event-store'
+import { Workspace, WorkspacesEvents } from '@ossy/workspaces'
+
+export const id = 'workspaces/remove-member'
+export const access = 'workspace'
+
+export async function run({ payload, req }) {
+  const createdBy = payload?.userId ?? req?.userId
+  const workspaceId = payload?.workspaceId ?? req?.workspaceId
+  const memberId = payload?.memberId ?? req?.memberId
+
+  if (!memberId) throw Object.assign(new Error('memberId is required'), { status: 400 })
+
+  const event = WorkspacesEvents.UserRemoved({ createdBy, userId: memberId })
+  await Aggregate.Of(Workspace, workspaceId).then(Aggregate.Add(event))
+  return null
+}

package/src/resource-templates.api.js

@@ -0,0 +1,35 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'resourceTemplates.root',
+  path: '/api/v0/resource-templates',
+}
+
+export default async function handle(req, res) {
+  if (req.method === 'POST') {
+    try {
+      const templates = await ActionService.invoke('workspaces/import-resource-templates', {
+        payload: { templates: req.body, workspaceId: req.workspaceId, userId: req.userId },
+        req,
+      })
+      res.json(templates)
+    } catch (err) {
+      res.status(err?.status ?? 500).json({ type: err?.type, message: err?.message })
+    }
+    return
+  }
+  if (req.method === 'GET') {
+    try {
+      const templates = await ActionService.invoke('workspaces/get-resource-templates', {
+        payload: { workspaceId: req.workspaceId },
+        req,
+      })
+      res.json(templates)
+    } catch (err) {
+      res.status(err?.status ?? 500).json()
+    }
+    return
+  }
+  res.setHeader('Allow', 'GET, POST')
+  res.status(405).json({ error: 'Method Not Allowed' })
+}

package/src/services-disable.api.js

@@ -0,0 +1,23 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.services.disable',
+  path: '/api/v0/services/disable',
+}
+
+export default async function handle(req, res) {
+  if (req.method !== 'POST') {
+    res.setHeader('Allow', 'POST')
+    res.status(405).json({ error: 'Method Not Allowed' })
+    return
+  }
+  try {
+    await ActionService.invoke('workspaces/disable-service', {
+      payload: { service: req.body?.service, workspaceId: req.workspaceId, userId: req.userId },
+      req,
+    })
+    res.json()
+  } catch (err) {
+    res.status(err?.status ?? 400).json({ error: err?.message })
+  }
+}

package/src/services-enable.api.js

@@ -0,0 +1,23 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.services.enable',
+  path: '/api/v0/services/enable',
+}
+
+export default async function handle(req, res) {
+  if (req.method !== 'POST') {
+    res.setHeader('Allow', 'POST')
+    res.status(405).json({ error: 'Method Not Allowed' })
+    return
+  }
+  try {
+    await ActionService.invoke('workspaces/enable-service', {
+      payload: { service: req.body, workspaceId: req.workspaceId, userId: req.userId },
+      req,
+    })
+    res.json()
+  } catch (err) {
+    res.status(err?.status ?? 400).json({ error: err?.message })
+  }
+}

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/tokens.api.js

@@ -0,0 +1,35 @@
+import { ActionService } from '@ossy/platform'
+
+export const metadata = {
+  id: 'workspaces.tokens',
+  path: '/api/v0/tokens',
+}
+
+export default async function handle(req, res) {
+  if (req.method === 'GET') {
+    try {
+      const tokens = await ActionService.invoke('workspaces/get-api-tokens', {
+        payload: { workspaceId: req.workspaceId },
+        req,
+      })
+      res.json(tokens)
+    } catch (err) {
+      res.status(err?.status ?? 500).json({ error: err?.message })
+    }
+    return
+  }
+  if (req.method === 'POST') {
+    try {
+      const token = await ActionService.invoke('workspaces/create-api-token', {
+        payload: { workspaceId: req.workspaceId, userId: req.userId, description: req.body?.description },
+        req,
+      })
+      res.json(token)
+    } catch (err) {
+      res.status(err?.status ?? 500).json({ error: err?.message })
+    }
+    return
+  }
+  res.setHeader('Allow', 'GET, POST')
+  res.status(405).json({ error: 'Method Not Allowed' })
+}

package/src/workspace-invitation.email.jsx

@@ -0,0 +1,18 @@
+import { EmailLayout, EmailButton, EmailText } from '@ossy/email'
+
+export const id = 'workspaces/invitation'
+export const subject = 'You have been invited'
+
+export default function WorkspaceInvitationEmail({ workspace, invitedBy, verificationToken, baseUrl = 'https://app.ossy.se', theme }) {
+  const verificationUrl = `${baseUrl}/invitations/verify?token=${verificationToken}&workspaceId=${workspace.id}`
+
+  return (
+    <EmailLayout theme={theme}>
+      <h1 style={{ color: '#111111', margin: '0 0 16px' }}>You have been invited</h1>
+      <EmailText>
+        You have been invited to contribute to {workspace.name} by {invitedBy}.
+      </EmailText>
+      <EmailButton href={verificationUrl} theme={theme}>Accept invitation</EmailButton>
+    </EmailLayout>
+  )
+}

package/src/workspaces.queries.js

@@ -0,0 +1,33 @@
+import { EventStore } from '@ossy/event-store'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('workspaces')
+
+export class WorkspacesQueries {
+  static getAllByUserIncluded(userId) {
+    log.info('[WorkspacesQueries] getAllByUserIncluded()')
+    return EventStore.Aggregate([
+      { $group: { _id: { aggregateId: '$aggregateId', aggregateType: '$aggregateType' }, events: { $push: '$$ROOT' } } },
+      {
+        $match: {
+          '_id.aggregateType': 'Workspace',
+          'events.createdBy': userId,
+          'events.type': { $nin: ['Deleted'], $in: ['Created', 'UserInvitationAccepted'] },
+        },
+      },
+      {
+        $project: {
+          events: '$events',
+          currentState: {
+            $reduce: {
+              input: '$events',
+              initialValue: {},
+              in: { id: '$_id.aggregateId', name: { $ifNull: ['$$this.payload.name', '$$value.name'] } },
+            },
+          },
+        },
+      },
+      { $project: { _id: 0, id: '$currentState.id', name: '$currentState.name' } },
+    ]).catch(() => [])
+  }
+}

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)
+    }))
+
+  })
+
+})