workspace invites

Author: vkarpov15

netlify/functions/getWorkspaceTeam.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const extrovert = require('extrovert');
+
+module.exports = extrovert.toNetlifyFunction(require('../../src/actions/getWorkspaceTeam'));

src/actions/getWorkspace.js

@@ -2,7 +2,6 @@
 
 const Archetype = require('archetype');
 const connect = require('../../src/db');
-const extrovert = require('extrovert');
 
 const GetWorkspaceParams = new Archetype({
   apiKey: {
@@ -18,5 +17,6 @@ module.exports = async function getWorkspace(params) {
   const { Workspace } = db.models;
 
   const workspace = await Workspace.findOne({ apiKey }).orFail();
+
   return { workspace };
 };

src/actions/getWorkspaceTeam.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const Archetype = require('archetype');
+const connect = require('../../src/db');
+const mongoose = require('mongoose');
+
+const GetInvitationsForWorkspaceParams = new Archetype({
+  authorization: {
+    $type: 'string',
+    $required: true
+  },
+  workspaceId: {
+    $type: mongoose.Types.ObjectId,
+    $required: true
+  }
+}).compile('GetInvitationsParams');
+
+module.exports = async function getWorkspaceTeam(params) {
+  const { authorization, workspaceId } = new GetInvitationsForWorkspaceParams(params);
+
+  const db = await connect();
+  const { AccessToken, Invitation, User, Workspace } = db.models;
+
+  // Find the user linked to the access token
+  const accessToken = await AccessToken.findById(authorization).orFail(new Error('Invalid access token'));
+  const userId = accessToken.userId;
+
+  // Find the workspace and check user permissions
+  const workspace = await Workspace.findById(workspaceId).orFail(new Error('Workspace not found'));
+
+  const isAuthorized = workspace.members.some(member =>
+    member.userId.toString() === userId.toString() && member.roles.find(role => role === 'admin' || role === 'owner')
+  );
+
+  if (!isAuthorized) {
+    throw new Error('User is not authorized to view workspace team');
+  }
+
+  // Fetch invitations with status "pending" or "declined"
+  const invitations = await Invitation.find({
+    workspaceId,
+    status: { $in: ['pending', 'declined'] }
+  });
+
+  const users = await User.find({ _id: { $in: workspace.members.map(member => member.userId) } });
+
+  return { invitations, users, workspace };
+};

src/actions/inviteToWorkspace.js

@@ -48,8 +48,8 @@ module.exports = async function inviteToWorkspace(params) {
 
   const isAlreadyMember = await User.exists(
     { _id: { $in: workspace.members.map(member => member.userId) },
-    githubUsername
-  });
+      githubUsername
+    });
   if (isAlreadyMember) {
     throw new Error(`${githubUsername} is already a member of this workspace`);
   }

src/db/invitation.js

@@ -13,6 +13,9 @@ const invitationSchema = new mongoose.Schema({
     type: String,
     required: true
   },
+  email: {
+    type: String
+  },
   invitedBy: {
     type: mongoose.Schema.Types.ObjectId,
     ref: 'User',

src/db/user.js

@@ -19,6 +19,9 @@ const userSchema = new mongoose.Schema({
   },
   githubUserId: {
     type: String
+  },
+  isFreeUser: {
+    type: Boolean
   }
 }, { timestamps: true, id: false });
 

test/getWorkspaceTeam.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const assert = require('assert');
+const { beforeEach, describe, it } = require('mocha');
+const connect = require('../src/db');
+const getWorkspaceTeam = require('../src/actions/getWorkspaceTeam');
+
+describe('getWorkspaceTeam', function() {
+  let db, User, AccessToken, Workspace, Invitation;
+  let adminUser, adminAccessToken, workspace, invitation1, invitation2;
+
+  beforeEach(async function() {
+    db = await connect();
+    ({ User, AccessToken, Workspace, Invitation } = db.models);
+
+    // Create an admin user
+    adminUser = await User.create({ email: '[email protected]', githubUsername: 'admin' });
+
+    // Create an access token for the admin
+    adminAccessToken = await AccessToken.create({ userId: adminUser._id });
+
+    // Create a workspace with the admin user
+    workspace = await Workspace.create({
+      name: 'Test Workspace',
+      ownerId: adminUser._id,
+      members: [{ userId: adminUser._id, roles: ['owner'] }],
+      baseUrl: 'https://example.com',
+      subscriptionTier: 'pro'
+    });
+
+    // Create invitations with "pending" and "declined" statuses
+    invitation1 = await Invitation.create({
+      workspaceId: workspace._id,
+      githubUsername: 'user1',
+      status: 'pending',
+      invitedBy: adminUser._id,
+      roles: ['member']
+    });
+
+    invitation2 = await Invitation.create({
+      workspaceId: workspace._id,
+      githubUsername: 'user2',
+      status: 'declined',
+      invitedBy: adminUser._id,
+      roles: ['admin']
+    });
+  });
+
+  it('should return pending and declined invitations if user is an admin or owner', async function() {
+    const result = await getWorkspaceTeam({
+      authorization: adminAccessToken._id.toString(),
+      workspaceId: workspace._id
+    });
+
+    assert.strictEqual(result.invitations.length, 2);
+    assert.strictEqual(result.invitations[0].workspaceId.toString(), workspace._id.toString());
+    assert.strictEqual(result.invitations[1].workspaceId.toString(), workspace._id.toString());
+    assert.deepStrictEqual(
+      result.invitations.map(invite => invite.status).sort(),
+      ['declined', 'pending']
+    );
+  });
+});

test/inviteToWorkspace.test.js

@@ -1,15 +1,15 @@
 'use strict';
 
+const { afterEach, beforeEach, describe, it } = require('mocha');
 const assert = require('assert');
-const mongoose = require('mongoose');
-const inviteToWorkspace = require('../src/actions/inviteToWorkspace');
 const connect = require('../src/db');
+const inviteToWorkspace = require('../src/actions/inviteToWorkspace');
 
-describe('inviteToWorkspace', function () {
+describe('inviteToWorkspace', function() {
   let db, AccessToken, User, Workspace, Invitation;
   let user, workspace, accessToken;
 
-  beforeEach(async function () {
+  beforeEach(async function() {
     // Connect to the real database
     db = await connect();
     ({ AccessToken, User, Workspace, Invitation } = db.models);
@@ -41,15 +41,15 @@ describe('inviteToWorkspace', function () {
     });
   });
 
-  afterEach(async function () {
+  afterEach(async function() {
     // Cleanup after tests
     await AccessToken.deleteMany({});
     await User.deleteMany({});
     await Workspace.deleteMany({});
     await Invitation.deleteMany({});
   });
 
-  it('should invite a user successfully', async function () {
+  it('should invite a user successfully', async function() {
     const result = await inviteToWorkspace({
       authorization: accessToken._id.toString(),
       workspaceId: workspace._id,
@@ -67,8 +67,8 @@ describe('inviteToWorkspace', function () {
     assert.strictEqual(invitationInDb.workspaceId.toString(), workspace._id.toString());
   });
 
-  
-  it('should fail if user is already a member of the workspace', async function () {
+
+  it('should fail if user is already a member of the workspace', async function() {
     const invitedUser = await User.create({
       name: 'Jane Smith',
       email: '[email protected]',
@@ -91,4 +91,3 @@ describe('inviteToWorkspace', function () {
     );
   });
 });
-