Complete first iteration of CRUD secrets operations by name

backend/src/controllers/v3/secretsController.ts

@@ -1,14 +1,8 @@
 import { Request, Response } from 'express';
 import { Types } from 'mongoose';
-import {
-    Secret
-} from '../../models';
-import crypto from 'crypto';
-import { SecretService } from '../../services';
-
-
-// TODO: modularize argon2id
-import * as argon2 from 'argon2';
+import { SecretService, TelemetryService } from '../../services';
+import { getAuthDataPayloadIdObj } from '../../utils/auth';
+import { BadRequestError } from '../../utils/errors';
 
 /**
  * Get secrets for workspace with id [workspaceId] and environment
@@ -17,41 +11,92 @@ import * as argon2 from 'argon2';
  * @param res 
  */
 export const getSecrets = async (req: Request, res: Response) => {
-    return res.status(200).send({
+    const workspaceId = req.query.workspaceId as string;
+    const environment = req.query.environment as string;
 
+    const secrets = await SecretService.getSecrets({
+        workspaceId: new Types.ObjectId(workspaceId),
+        environment,
+        authData: req.authData
+    });
+
+    const postHogClient = TelemetryService.getPostHogClient();
+    if (postHogClient) {
+        postHogClient.capture({
+            event: 'secrets pulled',
+            distinctId: TelemetryService.getDistinctId({
+                user: req.user,
+                serviceAccount: req.serviceAccount,
+                serviceTokenData: req.serviceTokenData
+            }),
+            properties: {
+                numberOfSecrets: secrets.length,
+                environment,
+                workspaceId,
+                channel: req.authData.authChannel,
+                userAgent: req.headers?.['user-agent']
+            }
+        });
+    }
+
+    return res.status(200).send({
+        secrets
     });
 }
 
 /**
- * Return secret with name [secretName] for workspace with id [workspaceId]
- * and environment [environment]
+ * Get secret with name [secretName]
  * @param req 
  * @param res 
  */
 export const getSecretByName = async (req: Request, res: Response) => {
     const { secretName } = req.params;
     const workspaceId = req.query.workspaceId as string;
-    const environment = req.query.workspaceId as string;
+    const environment = req.query.environment as string;
+    const type = req.query.type as 'shared' | 'personal' | undefined;
+    
+    const secret = await SecretService.getSecret({
+        secretName,
+        workspaceId: new Types.ObjectId(workspaceId),
+        environment,
+        type,
+        authData: req.authData
+    });
+
+    const postHogClient = TelemetryService.getPostHogClient();
+    if (postHogClient) {
+        postHogClient.capture({
+            event: 'secrets pull',
+            distinctId: TelemetryService.getDistinctId({
+                user: req.user,
+                serviceAccount: req.serviceAccount,
+                serviceTokenData: req.serviceTokenData
+            }),
+            properties: {
+                numberOfSecrets: 1,
+                environment,
+                workspaceId,
+                channel: req.authData.authChannel,
+                userAgent: req.headers?.['user-agent']
+            }
+        });
+    }
     
     return res.status(200).send({
-    
+        secret
     });
 }
 
 /**
- * Create secret for workspace with id [workspaceId] and
- * environment [environment]
+ * Create secret with name [secretName]
  * @param req 
  * @param res 
  */
 export const createSecret = async (req: Request, res: Response) => {
-    // TODO: the middleware should've prevalidated that the
-    // workspace with id [workspaceId] has disabled E2EE
     const { secretName } = req.params;
     const { 
         workspaceId,
         environment,
-        value,
         type,
         secretKeyCiphertext,
         secretKeyIV,
@@ -61,66 +106,140 @@ export const createSecret = async (req: Request, res: Response) => {
         secretValueTag
     } = req.body;
     
-    const secretBlindIndex = await SecretService.createSecretBlindIndex({
+    const secret = await SecretService.createSecret({
         secretName,
-        workspaceId: new Types.ObjectId(workspaceId)
+        workspaceId: new Types.ObjectId(workspaceId),
+        environment,
+        type,
+        authData: req.authData,
+        secretKeyCiphertext,
+        secretKeyIV,
+        secretKeyTag,
+        secretValueCiphertext,
+        secretValueIV,
+        secretValueTag
     });
-    
-    // // use workspace salt
-    // const randomBytes = crypto.randomBytes(16);
-    
-    // // generate blind index
-    // // TODO 1: abstract away into create blind index function
-    // // TODO 2: create a get blind index function
-    // const secretBlindIndex = (await argon2.hash(secretName, {
-    //     type: argon2.argon2id,
-    //     salt: randomBytes,
-    //     saltLength: 16, // default 16 bytes
-    //     memoryCost: 65536, // default pool of 64 MiB per thread.
-    //     hashLength: 32,
-    //     parallelism: 1,
-    //     raw: true
-    // })).toString('base64');
-    
-    // const secret = await new Secret({
-    //     workspace: new Types.ObjectId(workspaceId),
-    //     environment,
-    //     type,
-    //     secretBlindIndex,
-    //     secretKeyCiphertext,
-    //     secretKeyIV,
-    //     secretKeyTag,
-    //     secretValueCiphertext,
-    //     secretValueIV,
-    //     secretValueTag
-    // }).save();
+
+    const postHogClient = TelemetryService.getPostHogClient();
+    if (postHogClient) {
+        postHogClient.capture({
+            event: 'secrets added',
+            distinctId: TelemetryService.getDistinctId({
+                user: req.user,
+                serviceAccount: req.serviceAccount,
+                serviceTokenData: req.serviceTokenData
+            }),
+            properties: {
+                numberOfSecrets: 1,
+                environment,
+                workspaceId,
+                channel: req.authData.authChannel,
+                userAgent: req.headers?.['user-agent']
+            }
+        });
+    }
+
+    const secretWithoutBlindIndex = secret.toObject();
+    delete secretWithoutBlindIndex.secretBlindIndex;
     
     return res.status(200).send({
-    
+        secret: secretWithoutBlindIndex
     });
 }
 
 /**
- * Update secret with name [secretName] in workspace with id [workspaceId]
+ * Update secret with name [secretName]
  * @param req
  * @param res 
  */
 export const updateSecretByName = async (req: Request, res: Response) => {
     const { secretName } = req.params;
+    const {
+        workspaceId,
+        environment,
+        type,
+        secretValueCiphertext,
+        secretValueIV,
+        secretValueTag
+    } = req.body;
+
+    const secret = await SecretService.updateSecret({
+        secretName,
+        workspaceId,
+        environment,
+        type,
+        authData: req.authData,
+        secretValueCiphertext,
+        secretValueIV,
+        secretValueTag
+    });
+
+
+    const postHogClient = TelemetryService.getPostHogClient();
+    if (postHogClient) {
+        postHogClient.capture({
+            event: 'secrets modified',
+            distinctId: TelemetryService.getDistinctId({
+                user: req.user,
+                serviceAccount: req.serviceAccount,
+                serviceTokenData: req.serviceTokenData
+            }),
+            properties: {
+                numberOfSecrets: 1,
+                environment,
+                workspaceId,
+                channel: req.authData.authChannel,
+                userAgent: req.headers?.['user-agent']
+            }
+        });
+    }
 
     return res.status(200).send({
-    
+        secret
     });
 }
 
 /**
- * Delete secret with name [secretName] in workspace with id [workspaceId]
+ * Delete secret with name [secretName]
  * @param req 
  * @param res 
  */
 export const deleteSecretByName = async (req: Request, res: Response) => {
+    const { secretName } = req.params;
+    const {
+        workspaceId,
+        environment,
+        type
+    } = req.body;
     
+    const { secret, secrets } = await SecretService.deleteSecret({
+        secretName,
+        workspaceId,
+        environment,
+        type,
+        authData: req.authData
+    });
+
+    const postHogClient = TelemetryService.getPostHogClient();
+    if (postHogClient) {
+        postHogClient.capture({
+            event: 'secrets deleted',
+            distinctId: TelemetryService.getDistinctId({
+                user: req.user,
+                serviceAccount: req.serviceAccount,
+                serviceTokenData: req.serviceTokenData
+            }),
+            properties: {
+                numberOfSecrets: secrets.length,
+                environment,
+                workspaceId,
+                channel: req.authData.authChannel,
+                userAgent: req.headers?.['user-agent']
+            }
+        });
+    }
+
     return res.status(200).send({
-    
+        secret
     });
 }