refactor: rename groups to vaults

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

@@ -1,135 +0,0 @@
-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 { GroupUserServiceInterface } from '../Domain/GroupUser/Service/GroupUserServiceInterface'
-import { CreateGroupFileReadValetToken } from '../Domain/UseCase/CreateGroupFileValetToken/CreateGroupFileReadValetToken'
-
-@controller('/groups')
-export class GroupsController extends BaseHttpController {
-  constructor(
-    @inject(TYPES.GroupService) private groupService: GroupServiceInterface,
-    @inject(TYPES.GroupUserService) private groupUserService: GroupUserServiceInterface,
-    @inject(TYPES.GroupProjector) private groupProjector: ProjectorInterface<Group, GroupProjection>,
-    @inject(TYPES.GroupUserProjector) private groupUserProjector: ProjectorInterface<GroupUser, GroupUserProjection>,
-    @inject(TYPES.CreateGroupFileReadValetToken) private createGroupFileReadValetToken: CreateGroupFileReadValetToken,
-  ) {
-    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,
-    })
-
-    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,
-      groupKeyTimestamp: request.body.group_key_timestamp,
-      specifiedItemsKeyUuid: request.body.specified_items_key_uuid,
-    })
-
-    if (!result) {
-      return this.errorResponse(400, 'Could not create group')
-    }
-
-    const groupUser = await this.groupUserService.addGroupUser({
-      groupUuid: result.uuid,
-      userUuid: response.locals.user.uuid,
-      permissions: 'admin',
-    })
-
-    if (!groupUser) {
-      return this.errorResponse(400, 'Could not add user to group')
-    }
-
-    return this.json({
-      group: this.groupProjector.projectFull(result),
-      groupUser: this.groupUserProjector.projectFull(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,
-      groupKeyTimestamp: request.body.group_key_timestamp,
-      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 })
-  }
-
-  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,
-      groupUuids: request.body.group_uuids,
+      vaultUuids: request.body.vault_uuids,
       limit: request.body.limit,
       contentType: request.body.content_type,
       apiVersion: request.body.api ?? ApiVersion.v20161215,

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

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

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

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

@@ -0,0 +1,135 @@
+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 { VaultUserServiceInterface } from '../Domain/VaultUser/Service/VaultUserServiceInterface'
+import { CreateVaultFileReadValetToken } from '../Domain/UseCase/CreateVaultFileValetToken/CreateVaultFileReadValetToken'
+
+@controller('/vaults')
+export class VaultsController extends BaseHttpController {
+  constructor(
+    @inject(TYPES.VaultService) private vaultService: VaultServiceInterface,
+    @inject(TYPES.VaultUserService) private vaultUserService: VaultUserServiceInterface,
+    @inject(TYPES.VaultProjector) private vaultProjector: ProjectorInterface<Vault, VaultProjection>,
+    @inject(TYPES.VaultUserProjector) private vaultUserProjector: ProjectorInterface<VaultUser, VaultUserProjection>,
+    @inject(TYPES.CreateVaultFileReadValetToken) private createVaultFileReadValetToken: CreateVaultFileReadValetToken,
+  ) {
+    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,
+    })
+
+    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,
+      vaultKeyTimestamp: request.body.vault_key_timestamp,
+      specifiedItemsKeyUuid: request.body.specified_items_key_uuid,
+    })
+
+    if (!result) {
+      return this.errorResponse(400, 'Could not create vault')
+    }
+
+    const vaultUser = await this.vaultUserService.addVaultUser({
+      vaultUuid: result.uuid,
+      userUuid: response.locals.user.uuid,
+      permissions: 'admin',
+    })
+
+    if (!vaultUser) {
+      return this.errorResponse(400, 'Could not add user to vault')
+    }
+
+    return this.json({
+      vault: this.vaultProjector.projectFull(result),
+      vaultUser: this.vaultUserProjector.projectFull(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,
+      vaultKeyTimestamp: request.body.vault_key_timestamp,
+      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 })
+  }
+
+  private errorResponse(status: number, message?: string, tag?: string) {
+    return this.json(
+      {
+        error: { message, tag },
+      },
+      status,
+    )
+  }
+}