Fix merge conflicts

backend/src/services/auth/auth-login-service.ts

@@ -4,6 +4,7 @@ import { TUsers, UserDeviceSchema } from "@app/db/schemas";
 import { getConfig } from "@app/lib/config/env";
 import { generateSrpServerKey, srpCheckClientProof } from "@app/lib/crypto";
 import { BadRequestError } from "@app/lib/errors";
+import { getServerCfg } from "@app/services/super-admin/super-admin-service";
 
 import { TAuthTokenServiceFactory } from "../auth-token/auth-token-service";
 import { TokenType } from "../auth-token/auth-token-types";
@@ -265,20 +266,26 @@ export const authLoginServiceFactory = ({ userDAL, tokenService, smtpService }:
   /*
    * OAuth2 login for google,github, and other oauth2 provider
    * */
-  const oauth2Login = async ({
-    email,
-    firstName,
-    lastName,
-    authMethod,
-    callbackPort,
-    isSignupAllowed
-  }: TOauthLoginDTO) => {
+  const oauth2Login = async ({ email, firstName, lastName, authMethod, callbackPort }: TOauthLoginDTO) => {
     let user = await userDAL.findUserByEmail(email);
+    const serverCfg = await getServerCfg();
+
     const appCfg = getConfig();
-    const isOauthSignUpDisabled = !isSignupAllowed && !user;
-    if (isOauthSignUpDisabled) throw new BadRequestError({ message: "User signup disabled", name: "Oauth 2 login" });
 
     if (!user) {
+      // Create a new user based on oAuth
+      if (!serverCfg?.allowSignUp) throw new BadRequestError({ message: "Sign up disabled", name: "Oauth 2 login" });
+
+      if (serverCfg?.allowedSignUpDomain) {
+        const domain = email.split("@")[1];
+        const allowedDomains = serverCfg.allowedSignUpDomain.split(",").map((e) => e.trim());
+        if (!allowedDomains.includes(domain))
+          throw new BadRequestError({
+            message: `Email with a domain (@${domain}) is not supported`,
+            name: "Oauth 2 login"
+          });
+      }
+
       user = await userDAL.create({ email, firstName, lastName, authMethods: [authMethod], isGhost: false });
     }
     const isLinkingRequired = !user?.authMethods?.includes(authMethod);

backend/src/services/auth/auth-login-type.ts

@@ -28,5 +28,4 @@ export type TOauthLoginDTO = {
   lastName?: string;
   authMethod: AuthMethod;
   callbackPort?: string;
-  isSignupAllowed?: boolean;
 };

backend/src/services/project-membership/project-membership-service.ts

@@ -421,10 +421,6 @@ export const projectMembershipServiceFactory = ({
       });
     }
 
-    if (project.version === ProjectVersion.V1) {
-      throw new BadRequestError({ message: "Please upgrade your project on your dashboard" });
-    }
-
     const projectMembers = await projectMembershipDAL.findMembershipsByEmail(projectId, emails);
 
     if (projectMembers.length !== emails.length) {

backend/src/services/project/project-fns.ts

@@ -33,11 +33,12 @@ export const assignWorkspaceKeysToMembers = ({ members, decryptKey, userPrivateK
 type TCreateProjectKeyDTO = {
   publicKey: string;
   privateKey: string;
+  plainProjectKey?: string;
 };
 
-export const createProjectKey = ({ publicKey, privateKey }: TCreateProjectKeyDTO) => {
+export const createProjectKey = ({ publicKey, privateKey, plainProjectKey }: TCreateProjectKeyDTO) => {
   // 3. Create a random key that we'll use as the project key.
-  const randomBytes = crypto.randomBytes(16).toString("hex");
+  const randomBytes = plainProjectKey || crypto.randomBytes(16).toString("hex");
 
   // 4. Encrypt the project key with the users key pair.
   const { ciphertext: encryptedProjectKey, nonce: encryptedProjectKeyIv } = encryptAsymmetric(

backend/src/services/project/project-queue.ts

@@ -122,6 +122,13 @@ export const projectQueueFactory = ({
         tag: data.encryptedPrivateKey.encryptedKeyTag
       });
 
+      const decryptedPlainProjectKey = decryptAsymmetric({
+        ciphertext: oldProjectKey.encryptedKey,
+        nonce: oldProjectKey.nonce,
+        publicKey: oldProjectKey.sender.publicKey,
+        privateKey: userPrivateKey
+      });
+
       const projectEnvs = await projectEnvDAL.find({
         projectId: project.id
       });
@@ -199,6 +206,7 @@ export const projectQueueFactory = ({
 
         // Create a project key
         const { key: newEncryptedProjectKey, iv: newEncryptedProjectKeyIv } = createProjectKey({
+          plainProjectKey: decryptedPlainProjectKey,
           publicKey: ghostUser.keys.publicKey,
           privateKey: ghostUser.keys.plainPrivateKey
         });

backend/src/services/service-token/service-token-dal.ts

@@ -1,10 +1,32 @@
+import { Knex } from "knex";
+
 import { TDbClient } from "@app/db";
-import { TableName } from "@app/db/schemas";
-import { ormify } from "@app/lib/knex";
+import { TableName, TUsers } from "@app/db/schemas";
+import { DatabaseError } from "@app/lib/errors";
+import { ormify, selectAllTableCols } from "@app/lib/knex";
 
 export type TServiceTokenDALFactory = ReturnType<typeof serviceTokenDALFactory>;
 
 export const serviceTokenDALFactory = (db: TDbClient) => {
   const stOrm = ormify(db, TableName.ServiceToken);
-  return stOrm;
+
+  const findById = async (id: string, tx?: Knex) => {
+    try {
+      const doc = await (tx || db)(TableName.ServiceToken)
+        .leftJoin<TUsers>(
+          TableName.Users,
+          `${TableName.Users}.id`,
+          db.raw(`${TableName.ServiceToken}."createdBy"::uuid`)
+        )
+        .where(`${TableName.ServiceToken}.id`, id)
+        .select(selectAllTableCols(TableName.ServiceToken))
+        .select(db.ref("email").withSchema(TableName.Users).as("createdByEmail"))
+        .first();
+      return doc;
+    } catch (err) {
+      throw new DatabaseError({ error: err, name: "FindById" });
+    }
+  };
+
+  return { ...stOrm, findById };
 };

backend/src/services/service-token/service-token-service.ts

@@ -142,7 +142,7 @@ export const serviceTokenServiceFactory = ({
     const updatedToken = await serviceTokenDAL.updateById(serviceToken.id, {
       lastUsed: new Date()
     });
-    return updatedToken;
+    return { ...serviceToken, lastUsed: updatedToken.lastUsed };
   };
 
   return {

backend/src/services/telemetry/telemetry-service.ts

@@ -61,8 +61,15 @@ To opt into telemetry, you can set "TELEMETRY_ENABLED=true" within the environme
     }
   };
 
+  const flushAll = async () => {
+    if (postHog) {
+      await postHog.shutdownAsync();
+    }
+  };
+
   return {
     sendLoopsEvent,
-    sendPostHogEvents
+    sendPostHogEvents,
+    flushAll
   };
 };

backend/src/services/telemetry/telemetry-types.ts

@@ -8,7 +8,11 @@ export enum PostHogEventTypes {
   UserSignedUp = "User Signed Up",
   SecretRotated = "secrets rotated",
   SecretScannerFull = "historical cloud secret scan",
-  SecretScannerPush = "cloud secret scan"
+  SecretScannerPush = "cloud secret scan",
+  ProjectCreated = "Project Created",
+  IntegrationCreated = "Integration Created",
+  MachineIdentityCreated = "Machine Identity Created",
+  UserOrgInvitation = "User Org Invitation"
 }
 
 export type TSecretModifiedEvent = {
@@ -53,9 +57,57 @@ export type TSecretScannerEvent = {
   };
 };
 
+export type TProjectCreateEvent = {
+  event: PostHogEventTypes.ProjectCreated;
+  properties: {
+    name: string;
+    orgId: string;
+  };
+};
+
+export type TMachineIdentityCreatedEvent = {
+  event: PostHogEventTypes.MachineIdentityCreated;
+  properties: {
+    name: string;
+    orgId: string;
+    identityId: string;
+  };
+};
+
+export type TIntegrationCreatedEvent = {
+  event: PostHogEventTypes.IntegrationCreated;
+  properties: {
+    projectId: string;
+    integrationId: string;
+    integration: string; // TODO: fix type
+    environment: string;
+    secretPath: string;
+    url?: string;
+    app?: string;
+    appId?: string;
+    targetEnvironment?: string;
+    targetEnvironmentId?: string;
+    targetService?: string;
+    targetServiceId?: string;
+    path?: string;
+    region?: string;
+  };
+};
+
+export type TUserOrgInvitedEvent = {
+  event: PostHogEventTypes.UserOrgInvitation;
+  properties: {
+    inviteeEmail: string;
+  };
+};
+
 export type TPostHogEvent = { distinctId: string } & (
   | TSecretModifiedEvent
   | TAdminInitEvent
   | TUserSignedUpEvent
   | TSecretScannerEvent
+  | TUserOrgInvitedEvent
+  | TMachineIdentityCreatedEvent
+  | TIntegrationCreatedEvent
+  | TProjectCreateEvent
 );