Alessandro/web 1660 workspace cost items subtotal and currency (#2793)

* chore(workspaces): workspace cost schema

* chore(workspaces): test helper for workspace cost

* feat(workspaces): workspace billing cost

* fix(workspaces): fix onProjectCreated failing for the project creator if the creator is a member

* refactor(workspaces): change workspace cost calculation to a simpler query

* test(workspaceCost): fix costing logic and tests

* fix(workspaceTests): project emmiter needs owner now

---------

Co-authored-by: Gergő Jedlicska <gergo@jedlicska.com>

packages/server/modules/workspaces/tests/integration/workspaces.graph.spec.ts

@@ -38,12 +38,15 @@ import {
 } from '@/modules/workspaces/tests/helpers/creation'
 import { BasicTestCommit, createTestCommit } from '@/test/speckle-helpers/commitHelper'
 import { BasicTestStream, createTestStream } from '@/test/speckle-helpers/streamHelper'
-import knex from '@/db/knex'
+import knex, { db } from '@/db/knex'
 import {
   createRandomPassword,
-  createRandomEmail
+  createRandomEmail,
+  createRandomString
 } from '@/modules/core/helpers/testHelpers'
 import { getBranchesByStreamId } from '@/modules/core/services/branches'
+import { grantStreamPermissions } from '@/modules/core/repositories/streams'
+import { getWorkspaceFactory } from '@/modules/workspaces/repositories/workspaces'
 
 const createProjectWithVersions =
   ({ apollo }: { apollo: TestApolloServer }) =>
@@ -230,13 +233,117 @@ describe('Workspaces GQL CRUD', () => {
           max: 500
         })
       })
+      it('should return workspace cost', async () => {
+        const createRes = await apollo.execute(CreateWorkspaceDocument, {
+          input: { name: createRandomString() }
+        })
+        expect(createRes).to.not.haveGraphQLErrors()
+        const workspaceId = createRes.data!.workspaceMutations.create.id
+        const workspace = (await getWorkspaceFactory({ db })({
+          workspaceId
+        })) as unknown as BasicTestWorkspace
+
+        const member = {
+          id: createRandomString(),
+          name: createRandomPassword(),
+          email: createRandomEmail()
+        }
+        const guestWithWritePermission = {
+          id: createRandomString(),
+          name: createRandomPassword(),
+          email: createRandomEmail()
+        }
+        const viewer = {
+          id: createRandomString(),
+          name: createRandomPassword(),
+          email: createRandomEmail()
+        }
+        const viewer2 = {
+          id: createRandomString(),
+          name: createRandomPassword(),
+          email: createRandomEmail()
+        }
+
+        await Promise.all([
+          createTestUser(member),
+          createTestUser(guestWithWritePermission),
+          createTestUser(viewer),
+          createTestUser(viewer2)
+        ])
+
+        await Promise.all([
+          assignToWorkspace(workspace, member, Roles.Workspace.Member),
+          assignToWorkspace(workspace, guestWithWritePermission, Roles.Workspace.Guest),
+          assignToWorkspace(workspace, viewer, Roles.Workspace.Guest),
+          assignToWorkspace(workspace, viewer2, Roles.Workspace.Guest)
+        ])
+
+        const resProject1 = await apollo.execute(CreateProjectDocument, {
+          input: {
+            name: createRandomPassword(),
+            workspaceId
+          }
+        })
+        expect(resProject1).to.not.haveGraphQLErrors()
+        const project1Id = resProject1.data!.projectMutations.create.id
+
+        await Promise.all([
+          grantStreamPermissions({
+            streamId: project1Id,
+            userId: guestWithWritePermission.id,
+            role: Roles.Stream.Contributor
+          }),
+          grantStreamPermissions({
+            streamId: project1Id,
+            userId: viewer.id,
+            role: Roles.Stream.Reviewer
+          }),
+          grantStreamPermissions({
+            streamId: project1Id,
+            userId: viewer2.id,
+            role: Roles.Stream.Reviewer
+          })
+        ])
+
+        const res = await apollo.execute(GetWorkspaceWithBillingDocument, {
+          workspaceId
+        })
+
+        expect(res).to.not.haveGraphQLErrors()
+        const { subTotal, currency, items } = res.data!.workspace.billing.cost
+        expect(subTotal).to.equal(70 + 50 + 10)
+        expect(currency).to.equal('GBP')
+        expect(items).to.deep.equal([
+          {
+            name: 'workspace admin',
+            count: 1,
+            cost: 70
+          },
+          {
+            name: 'workspace member',
+            count: 1,
+            cost: 50
+          },
+          {
+            name: 'read/write guest',
+            count: 1,
+            cost: 10
+          },
+          {
+            name: 'read only guest',
+            count: 2,
+            cost: 0
+          }
+        ])
+      })
     })
 
     describe('query activeUser.workspaces', () => {
       it('should return all workspaces for a user', async () => {
         const res = await apollo.execute(GetActiveUserWorkspacesDocument, {})
         expect(res).to.not.haveGraphQLErrors()
-        expect(res.data?.activeUser?.workspaces?.items?.length).to.equal(1)
+        // TODO: this test depends on the previous tests
+        expect(res.data?.activeUser?.workspaces?.items?.length).to.equal(2)
       })
     })