refactor: rename vaults to groups

packages/syncing-server/src/Controller/GroupInvitesController.ts

@@ -10,29 +10,29 @@ import {
 } from 'inversify-express-utils'
 import TYPES from '../Bootstrap/Types'
 import { inject } from 'inversify'
-import { VaultInviteServiceInterface } from '../Domain/VaultInvite/Service/VaultInviteServiceInterface'
-import { VaultInviteProjector } from '../Projection/VaultInviteProjector'
+import { GroupInviteServiceInterface } from '../Domain/GroupInvite/Service/GroupInviteServiceInterface'
+import { GroupInviteProjector } from '../Projection/GroupInviteProjector'
 
-@controller('/vaults')
-export class VaultInvitesController extends BaseHttpController {
+@controller('/groups')
+export class GroupInvitesController extends BaseHttpController {
   constructor(
-    @inject(TYPES.VaultInviteService) private vaultInviteService: VaultInviteServiceInterface,
-    @inject(TYPES.VaultInviteProjector) private vaultInviteProjector: VaultInviteProjector,
+    @inject(TYPES.GroupInviteService) private groupInviteService: GroupInviteServiceInterface,
+    @inject(TYPES.GroupInviteProjector) private groupInviteProjector: GroupInviteProjector,
   ) {
     super()
   }
 
-  @httpPost('/:vaultUuid/invites', TYPES.AuthMiddleware)
-  public async createVaultInvite(
+  @httpPost('/:groupUuid/invites', TYPES.AuthMiddleware)
+  public async createGroupInvite(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.createInvite({
+    const result = await this.groupInviteService.createInvite({
       originatorUuid: response.locals.user.uuid,
-      vaultUuid: request.params.vaultUuid,
+      groupUuid: request.params.groupUuid,
       userUuid: request.body.invitee_uuid,
       inviterPublicKey: request.body.inviter_public_key,
-      encryptedVaultData: request.body.encrypted_vault_data,
+      encryptedGroupData: request.body.encrypted_group_data,
       inviteType: request.body.invite_type,
       permissions: request.body.permissions,
     })
@@ -41,19 +41,19 @@ export class VaultInvitesController extends BaseHttpController {
       return this.errorResponse(400, 'Could not create invite')
     }
 
-    return this.json({ invite: this.vaultInviteProjector.projectFull(result) })
+    return this.json({ invite: this.groupInviteProjector.projectFull(result) })
   }
 
-  @httpPatch('/:vaultUuid/invites/:inviteUuid', TYPES.AuthMiddleware)
-  public async updateVaultInvite(
+  @httpPatch('/:groupUuid/invites/:inviteUuid', TYPES.AuthMiddleware)
+  public async updateGroupInvite(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.updateInvite({
+    const result = await this.groupInviteService.updateInvite({
       originatorUuid: response.locals.user.uuid,
       inviteUuid: request.params.inviteUuid,
       inviterPublicKey: request.body.inviter_public_key,
-      encryptedVaultData: request.body.encrypted_vault_data,
+      encryptedGroupData: request.body.encrypted_group_data,
       permissions: request.body.permissions,
     })
 
@@ -61,15 +61,15 @@ export class VaultInvitesController extends BaseHttpController {
       return this.errorResponse(400, 'Could not update invite')
     }
 
-    return this.json({ invite: this.vaultInviteProjector.projectFull(result) })
+    return this.json({ invite: this.groupInviteProjector.projectFull(result) })
   }
 
-  @httpPost('/:vaultUuid/invites/:inviteUuid/accept', TYPES.AuthMiddleware)
-  public async acceptVaultInvite(
+  @httpPost('/:groupUuid/invites/:inviteUuid/accept', TYPES.AuthMiddleware)
+  public async acceptGroupInvite(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.acceptInvite({
+    const result = await this.groupInviteService.acceptInvite({
       originatorUuid: response.locals.user.uuid,
       inviteUuid: request.params.inviteUuid,
     })
@@ -81,12 +81,12 @@ export class VaultInvitesController extends BaseHttpController {
     return this.json({ success: true })
   }
 
-  @httpPost('/:vaultUuid/invites/:inviteUuid/decline', TYPES.AuthMiddleware)
-  public async declineVaultInvite(
+  @httpPost('/:groupUuid/invites/:inviteUuid/decline', TYPES.AuthMiddleware)
+  public async declineGroupInvite(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.declineInvite({
+    const result = await this.groupInviteService.declineInvite({
       originatorUuid: response.locals.user.uuid,
       inviteUuid: request.params.inviteUuid,
     })
@@ -103,7 +103,7 @@ export class VaultInvitesController extends BaseHttpController {
     _request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    await this.vaultInviteService.deleteAllInboundInvites({
+    await this.groupInviteService.deleteAllInboundInvites({
       userUuid: response.locals.user.uuid,
     })
 
@@ -115,15 +115,15 @@ export class VaultInvitesController extends BaseHttpController {
     _request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.getOutboundInvitesForUser({
+    const result = await this.groupInviteService.getOutboundInvitesForUser({
       userUuid: response.locals.user.uuid,
     })
 
     if (!result) {
-      return this.errorResponse(400, 'Could not get vault invites')
+      return this.errorResponse(400, 'Could not get group invites')
     }
 
-    const projected = result.map((invite) => this.vaultInviteProjector.projectFull(invite))
+    const projected = result.map((invite) => this.groupInviteProjector.projectFull(invite))
 
     return this.json({ invites: projected })
   }
@@ -133,46 +133,46 @@ export class VaultInvitesController extends BaseHttpController {
     _request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.getInvitesForUser({
+    const result = await this.groupInviteService.getInvitesForUser({
       userUuid: response.locals.user.uuid,
     })
 
     if (!result) {
-      return this.errorResponse(400, 'Could not get vault invites')
+      return this.errorResponse(400, 'Could not get group invites')
     }
 
-    const projected = result.map((invite) => this.vaultInviteProjector.projectFull(invite))
+    const projected = result.map((invite) => this.groupInviteProjector.projectFull(invite))
 
     return this.json({ invites: projected })
   }
 
-  @httpGet('/:vaultUuid/invites', TYPES.AuthMiddleware)
-  public async getVaultInvites(
+  @httpGet('/:groupUuid/invites', TYPES.AuthMiddleware)
+  public async getGroupInvites(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.getInvitesForVault({
+    const result = await this.groupInviteService.getInvitesForGroup({
       originatorUuid: response.locals.user.uuid,
-      vaultUuid: request.params.vaultUuid,
+      groupUuid: request.params.groupUuid,
     })
 
     if (!result) {
-      return this.errorResponse(400, 'Could not get vault invites')
+      return this.errorResponse(400, 'Could not get group invites')
     }
 
-    const projected = result.map((invite) => this.vaultInviteProjector.projectFull(invite))
+    const projected = result.map((invite) => this.groupInviteProjector.projectFull(invite))
 
     return this.json({ invites: projected })
   }
 
-  @httpDelete('/:vaultUuid/invites/:inviteUuid', TYPES.AuthMiddleware)
-  public async deleteVaultInvite(
+  @httpDelete('/:groupUuid/invites/:inviteUuid', TYPES.AuthMiddleware)
+  public async deleteGroupInvite(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultInviteService.deleteInvite({
+    const result = await this.groupInviteService.deleteInvite({
       originatorUuid: response.locals.user.uuid,
-      vaultUuid: request.params.vaultUuid,
+      groupUuid: request.params.groupUuid,
       inviteUuid: request.params.inviteUuid,
     })
 

packages/syncing-server/src/Controller/GroupUsersController.ts

@@ -2,48 +2,48 @@ import { Request, Response } from 'express'
 import { BaseHttpController, controller, results, httpDelete, httpGet } from 'inversify-express-utils'
 import TYPES from '../Bootstrap/Types'
 import { inject } from 'inversify'
-import { VaultUserServiceInterface } from '../Domain/VaultUser/Service/VaultUserServiceInterface'
-import { VaultUserProjector } from '../Projection/VaultUserProjector'
+import { GroupUserServiceInterface } from '../Domain/GroupUser/Service/GroupUserServiceInterface'
+import { GroupUserProjector } from '../Projection/GroupUserProjector'
 
-@controller('/vaults/:vaultUuid/users')
-export class VaultUsersController extends BaseHttpController {
+@controller('/groups/:groupUuid/users')
+export class GroupUsersController extends BaseHttpController {
   constructor(
-    @inject(TYPES.VaultUserService) private vaultUserService: VaultUserServiceInterface,
-    @inject(TYPES.VaultUserProjector) private vaultUserProjector: VaultUserProjector,
+    @inject(TYPES.GroupUserService) private groupUserService: GroupUserServiceInterface,
+    @inject(TYPES.GroupUserProjector) private groupUserProjector: GroupUserProjector,
   ) {
     super()
   }
 
   @httpGet('/', TYPES.AuthMiddleware)
-  public async getVaultUsers(
+  public async getGroupUsers(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultUserService.getVaultUsersForVault({
+    const result = await this.groupUserService.getGroupUsersForGroup({
       originatorUuid: response.locals.user.uuid,
-      vaultUuid: request.params.vaultUuid,
+      groupUuid: request.params.groupUuid,
     })
 
     if (!result) {
-      return this.errorResponse(400, 'Could not get vault users')
+      return this.errorResponse(400, 'Could not get group users')
     }
 
     const { users, isAdmin } = result
 
-    const projected = users.map((vaultUser) =>
-      this.vaultUserProjector.projectAsDisplayableUserForOtherVaultMembers(vaultUser, isAdmin),
+    const projected = users.map((groupUser) =>
+      this.groupUserProjector.projectAsDisplayableUserForOtherGroupMembers(groupUser, isAdmin),
     )
 
     return this.json({ users: projected })
   }
 
   @httpDelete('/:userUuid', TYPES.AuthMiddleware)
-  public async deleteVaultUser(
+  public async deleteGroupUser(
     request: Request,
     response: Response,
   ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultUserService.deleteVaultUser({
-      vaultUuid: request.params.vaultUuid,
+    const result = await this.groupUserService.deleteGroupUser({
+      groupUuid: request.params.groupUuid,
       userUuid: request.params.userUuid,
       originatorUuid: response.locals.user.uuid,
     })

packages/syncing-server/src/Controller/GroupsController.ts

@@ -0,0 +1,150 @@
+import { GroupUser } from '../Domain/GroupUser/Model/GroupUser'
+import { GroupServiceInterface } from '../Domain/Group/Service/GroupServiceInterface'
+import { Request, Response } from 'express'
+import {
+  BaseHttpController,
+  controller,
+  httpPost,
+  results,
+  httpDelete,
+  httpPatch,
+  httpGet,
+} from 'inversify-express-utils'
+import TYPES from '../Bootstrap/Types'
+import { inject } from 'inversify'
+import { ProjectorInterface } from '../Projection/ProjectorInterface'
+import { Group } from '../Domain/Group/Model/Group'
+import { GroupProjection } from '../Projection/GroupProjection'
+import { GroupUserProjection } from '../Projection/GroupUserProjection'
+import { CreateGroupFileValetToken } from '../Domain/UseCase/CreateGroupFileValetToken/CreateGroupFileValetToken'
+import { RemovedGroupUserServiceInterface } from '../Domain/RemovedGroupUser/Service/RemovedGroupUserServiceInterface'
+
+@controller('/groups')
+export class GroupsController extends BaseHttpController {
+  constructor(
+    @inject(TYPES.GroupService) private groupService: GroupServiceInterface,
+    @inject(TYPES.RemovedGroupUserService) private removedGroupUserService: RemovedGroupUserServiceInterface,
+    @inject(TYPES.GroupProjector) private groupProjector: ProjectorInterface<Group, GroupProjection>,
+    @inject(TYPES.GroupUserProjector) private groupUserProjector: ProjectorInterface<GroupUser, GroupUserProjection>,
+    @inject(TYPES.CreateGroupFileReadValetToken) private createGroupFileReadValetToken: CreateGroupFileValetToken,
+  ) {
+    super()
+  }
+
+  @httpGet('/', TYPES.AuthMiddleware)
+  public async getGroups(_request: Request, response: Response): Promise<results.JsonResult> {
+    const groups = await this.groupService.getGroups({
+      userUuid: response.locals.user.uuid,
+    })
+
+    return this.json({
+      groups: groups.map((group) => this.groupProjector.projectFull(group)),
+    })
+  }
+
+  @httpPost('/:groupUuid/valet-tokens', TYPES.AuthMiddleware)
+  public async getValetTokenForGroupFile(
+    request: Request,
+    response: Response,
+  ): Promise<results.NotFoundResult | results.JsonResult> {
+    const valetTokenResult = await this.createGroupFileReadValetToken.execute({
+      userUuid: response.locals.user.uuid,
+      groupUuid: request.params.groupUuid,
+      fileUuid: request.body.file_uuid,
+      remoteIdentifier: request.body.remote_identifier,
+      operation: request.body.operation,
+      unencryptedFileSize: request.body.unencrypted_file_size,
+      moveOperationType: request.body.move_operation_type,
+      groupToGroupMoveTargetUuid: request.body.group_to_group_move_target_uuid,
+    })
+
+    if (valetTokenResult.success === false) {
+      return this.errorResponse(400, `Failed to create group valet token: ${valetTokenResult.reason}`)
+    }
+
+    return this.json({
+      valetToken: valetTokenResult.valetToken,
+    })
+  }
+
+  @httpPost('/', TYPES.AuthMiddleware)
+  public async createGroup(request: Request, response: Response): Promise<results.NotFoundResult | results.JsonResult> {
+    const result = await this.groupService.createGroup({
+      userUuid: response.locals.user.uuid,
+      groupUuid: request.body.group_uuid,
+      specifiedItemsKeyUuid: request.body.specified_items_key_uuid,
+    })
+
+    if (!result) {
+      return this.errorResponse(400, 'Could not create group')
+    }
+
+    return this.json({
+      group: this.groupProjector.projectFull(result.group),
+      groupUser: this.groupUserProjector.projectFull(result.groupUser),
+    })
+  }
+
+  @httpPatch('/:groupUuid', TYPES.AuthMiddleware)
+  public async updateGroup(request: Request, response: Response): Promise<results.NotFoundResult | results.JsonResult> {
+    const result = await this.groupService.updateGroup({
+      groupUuid: request.params.groupUuid,
+      originatorUuid: response.locals.user.uuid,
+      specifiedItemsKeyUuid: request.body.specified_items_key_uuid,
+    })
+
+    if (!result) {
+      return this.errorResponse(400, 'Could not update group')
+    }
+
+    return this.json({
+      group: this.groupProjector.projectFull(result),
+    })
+  }
+
+  @httpDelete('/:groupUuid', TYPES.AuthMiddleware)
+  public async deleteGroup(request: Request, response: Response): Promise<results.NotFoundResult | results.JsonResult> {
+    const result = await this.groupService.deleteGroup({
+      groupUuid: request.params.groupUuid,
+      originatorUuid: response.locals.user.uuid,
+    })
+
+    if (!result) {
+      return this.errorResponse(400, 'Could not delete group')
+    }
+
+    return this.json({ success: true })
+  }
+
+  @httpGet('/removed', TYPES.AuthMiddleware)
+  public async getAllRemovedFromGroupsForCurrentUser(
+    _request: Request,
+    response: Response,
+  ): Promise<results.NotFoundResult | results.JsonResult> {
+    const result = await this.removedGroupUserService.getAllRemovedGroupUsersForUser({
+      userUuid: response.locals.user.uuid,
+    })
+
+    if (!result) {
+      return this.errorResponse(400, 'Could not get group users')
+    }
+
+    return this.json({
+      removedGroups: result.map((removedUser) => {
+        return {
+          groupUuid: removedUser.groupUuid,
+          removedAt: removedUser.createdAtTimestamp,
+        }
+      }),
+    })
+  }
+
+  private errorResponse(status: number, message?: string, tag?: string) {
+    return this.json(
+      {
+        error: { message, tag },
+      },
+      status,
+    )
+  }
+}

packages/syncing-server/src/Controller/ItemsController.ts

@@ -37,7 +37,7 @@ export class ItemsController extends BaseHttpController {
       computeIntegrityHash: request.body.compute_integrity === true,
       syncToken: request.body.sync_token,
       cursorToken: request.body.cursor_token,
-      vaultUuids: request.body.vault_uuids,
+      groupUuids: request.body.group_uuids,
       limit: request.body.limit,
       contentType: request.body.content_type,
       apiVersion: request.body.api ?? ApiVersion.v20161215,

packages/syncing-server/src/Controller/VaultsController.ts

@@ -1,150 +0,0 @@
-import { VaultUser } from '../Domain/VaultUser/Model/VaultUser'
-import { VaultServiceInterface } from '../Domain/Vault/Service/VaultServiceInterface'
-import { Request, Response } from 'express'
-import {
-  BaseHttpController,
-  controller,
-  httpPost,
-  results,
-  httpDelete,
-  httpPatch,
-  httpGet,
-} from 'inversify-express-utils'
-import TYPES from '../Bootstrap/Types'
-import { inject } from 'inversify'
-import { ProjectorInterface } from '../Projection/ProjectorInterface'
-import { Vault } from '../Domain/Vault/Model/Vault'
-import { VaultProjection } from '../Projection/VaultProjection'
-import { VaultUserProjection } from '../Projection/VaultUserProjection'
-import { CreateVaultFileValetToken } from '../Domain/UseCase/CreateVaultFileValetToken/CreateVaultFileValetToken'
-import { RemovedVaultUserServiceInterface } from '../Domain/RemovedVaultUser/Service/RemovedVaultUserServiceInterface'
-
-@controller('/vaults')
-export class VaultsController extends BaseHttpController {
-  constructor(
-    @inject(TYPES.VaultService) private vaultService: VaultServiceInterface,
-    @inject(TYPES.RemovedVaultUserService) private removedVaultUserService: RemovedVaultUserServiceInterface,
-    @inject(TYPES.VaultProjector) private vaultProjector: ProjectorInterface<Vault, VaultProjection>,
-    @inject(TYPES.VaultUserProjector) private vaultUserProjector: ProjectorInterface<VaultUser, VaultUserProjection>,
-    @inject(TYPES.CreateVaultFileReadValetToken) private createVaultFileReadValetToken: CreateVaultFileValetToken,
-  ) {
-    super()
-  }
-
-  @httpGet('/', TYPES.AuthMiddleware)
-  public async getVaults(_request: Request, response: Response): Promise<results.JsonResult> {
-    const vaults = await this.vaultService.getVaults({
-      userUuid: response.locals.user.uuid,
-    })
-
-    return this.json({
-      vaults: vaults.map((vault) => this.vaultProjector.projectFull(vault)),
-    })
-  }
-
-  @httpPost('/:vaultUuid/valet-tokens', TYPES.AuthMiddleware)
-  public async getValetTokenForVaultFile(
-    request: Request,
-    response: Response,
-  ): Promise<results.NotFoundResult | results.JsonResult> {
-    const valetTokenResult = await this.createVaultFileReadValetToken.execute({
-      userUuid: response.locals.user.uuid,
-      vaultUuid: request.params.vaultUuid,
-      fileUuid: request.body.file_uuid,
-      remoteIdentifier: request.body.remote_identifier,
-      operation: request.body.operation,
-      unencryptedFileSize: request.body.unencrypted_file_size,
-      moveOperationType: request.body.move_operation_type,
-      vaultToVaultMoveTargetUuid: request.body.vault_to_vault_move_target_uuid,
-    })
-
-    if (valetTokenResult.success === false) {
-      return this.errorResponse(400, `Failed to create vault valet token: ${valetTokenResult.reason}`)
-    }
-
-    return this.json({
-      valetToken: valetTokenResult.valetToken,
-    })
-  }
-
-  @httpPost('/', TYPES.AuthMiddleware)
-  public async createVault(request: Request, response: Response): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultService.createVault({
-      userUuid: response.locals.user.uuid,
-      vaultUuid: request.body.vault_uuid,
-      specifiedItemsKeyUuid: request.body.specified_items_key_uuid,
-    })
-
-    if (!result) {
-      return this.errorResponse(400, 'Could not create vault')
-    }
-
-    return this.json({
-      vault: this.vaultProjector.projectFull(result.vault),
-      vaultUser: this.vaultUserProjector.projectFull(result.vaultUser),
-    })
-  }
-
-  @httpPatch('/:vaultUuid', TYPES.AuthMiddleware)
-  public async updateVault(request: Request, response: Response): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultService.updateVault({
-      vaultUuid: request.params.vaultUuid,
-      originatorUuid: response.locals.user.uuid,
-      specifiedItemsKeyUuid: request.body.specified_items_key_uuid,
-    })
-
-    if (!result) {
-      return this.errorResponse(400, 'Could not update vault')
-    }
-
-    return this.json({
-      vault: this.vaultProjector.projectFull(result),
-    })
-  }
-
-  @httpDelete('/:vaultUuid', TYPES.AuthMiddleware)
-  public async deleteVault(request: Request, response: Response): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.vaultService.deleteVault({
-      vaultUuid: request.params.vaultUuid,
-      originatorUuid: response.locals.user.uuid,
-    })
-
-    if (!result) {
-      return this.errorResponse(400, 'Could not delete vault')
-    }
-
-    return this.json({ success: true })
-  }
-
-  @httpGet('/removed', TYPES.AuthMiddleware)
-  public async getAllRemovedFromVaultsForCurrentUser(
-    _request: Request,
-    response: Response,
-  ): Promise<results.NotFoundResult | results.JsonResult> {
-    const result = await this.removedVaultUserService.getAllRemovedVaultUsersForUser({
-      userUuid: response.locals.user.uuid,
-    })
-
-    if (!result) {
-      return this.errorResponse(400, 'Could not get vault users')
-    }
-
-    return this.json({
-      removedVaults: result.map((removedUser) => {
-        return {
-          vaultUuid: removedUser.vaultUuid,
-          removedAt: removedUser.createdAtTimestamp,
-        }
-      }),
-    })
-  }
-
-  private errorResponse(status: number, message?: string, tag?: string) {
-    return this.json(
-      {
-        error: { message, tag },
-      },
-      status,
-    )
-  }
-}