app connection + finishing touches

backend/src/services/app-connection/app-connection-enums.ts

@@ -66,3 +66,8 @@ export enum AWSRegion {
   // South America
   SA_EAST_1 = "sa-east-1" // Sao Paulo
 }
+
+export enum AppConnectionPlanType {
+  Enterprise = "enterprise",
+  Regular = "regular"
+}

backend/src/services/app-connection/app-connection-fns.ts

@@ -8,6 +8,11 @@ import {
 } from "@app/services/app-connection/shared/sql";
 import { KmsDataKey } from "@app/services/kms/kms-types";
 
+import {
+  getOCIConnectionListItem,
+  OCIConnectionMethod,
+  validateOCIConnectionCredentials
+} from "../../ee/services/app-connections/oci";
 import { AppConnection } from "./app-connection-enums";
 import { TAppConnectionServiceFactoryDep } from "./app-connection-service";
 import {
@@ -53,7 +58,6 @@ import {
 } from "./humanitec";
 import { getLdapConnectionListItem, LdapConnectionMethod, validateLdapConnectionCredentials } from "./ldap";
 import { getMsSqlConnectionListItem, MsSqlConnectionMethod } from "./mssql";
-import { getOCIConnectionListItem, OCIConnectionMethod, validateOCIConnectionCredentials } from "./oci";
 import { getPostgresConnectionListItem, PostgresConnectionMethod } from "./postgres";
 import {
   getTeamCityConnectionListItem,

backend/src/services/app-connection/app-connection-maps.ts

@@ -1,4 +1,4 @@
-import { AppConnection } from "./app-connection-enums";
+import { AppConnection, AppConnectionPlanType } from "./app-connection-enums";
 
 export const APP_CONNECTION_NAME_MAP: Record<AppConnection, string> = {
   [AppConnection.AWS]: "AWS",
@@ -21,3 +21,25 @@ export const APP_CONNECTION_NAME_MAP: Record<AppConnection, string> = {
   [AppConnection.TeamCity]: "TeamCity",
   [AppConnection.OCI]: "OCI"
 };
+
+export const APP_CONNECTION_PLAN_MAP: Record<AppConnection, AppConnectionPlanType> = {
+  [AppConnection.AWS]: AppConnectionPlanType.Regular,
+  [AppConnection.GitHub]: AppConnectionPlanType.Regular,
+  [AppConnection.GCP]: AppConnectionPlanType.Regular,
+  [AppConnection.AzureKeyVault]: AppConnectionPlanType.Regular,
+  [AppConnection.AzureAppConfiguration]: AppConnectionPlanType.Regular,
+  [AppConnection.AzureClientSecrets]: AppConnectionPlanType.Regular,
+  [AppConnection.Databricks]: AppConnectionPlanType.Regular,
+  [AppConnection.Humanitec]: AppConnectionPlanType.Regular,
+  [AppConnection.TerraformCloud]: AppConnectionPlanType.Regular,
+  [AppConnection.Vercel]: AppConnectionPlanType.Regular,
+  [AppConnection.Postgres]: AppConnectionPlanType.Regular,
+  [AppConnection.MsSql]: AppConnectionPlanType.Regular,
+  [AppConnection.Camunda]: AppConnectionPlanType.Regular,
+  [AppConnection.Windmill]: AppConnectionPlanType.Regular,
+  [AppConnection.Auth0]: AppConnectionPlanType.Regular,
+  [AppConnection.HCVault]: AppConnectionPlanType.Regular,
+  [AppConnection.LDAP]: AppConnectionPlanType.Regular,
+  [AppConnection.TeamCity]: AppConnectionPlanType.Regular,
+  [AppConnection.OCI]: AppConnectionPlanType.Enterprise
+};

backend/src/services/app-connection/app-connection-service.ts

@@ -1,5 +1,6 @@
 import { ForbiddenError, subject } from "@casl/ability";
 
+import { TLicenseServiceFactory } from "@app/ee/services/license/license-service";
 import { OrgPermissionAppConnectionActions, OrgPermissionSubjects } from "@app/ee/services/permission/org-permission";
 import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service";
 import { generateHash } from "@app/lib/crypto/encryption";
@@ -17,9 +18,11 @@ import {
 import { auth0ConnectionService } from "@app/services/app-connection/auth0/auth0-connection-service";
 import { TKmsServiceFactory } from "@app/services/kms/kms-service";
 
+import { ValidateOCIConnectionCredentialsSchema } from "../../ee/services/app-connections/oci";
+import { ociConnectionService } from "../../ee/services/app-connections/oci/oci-connection-service";
 import { TAppConnectionDALFactory } from "./app-connection-dal";
-import { AppConnection } from "./app-connection-enums";
-import { APP_CONNECTION_NAME_MAP } from "./app-connection-maps";
+import { AppConnection, AppConnectionPlanType } from "./app-connection-enums";
+import { APP_CONNECTION_NAME_MAP, APP_CONNECTION_PLAN_MAP } from "./app-connection-maps";
 import {
   TAppConnection,
   TAppConnectionConfig,
@@ -49,8 +52,6 @@ import { ValidateHumanitecConnectionCredentialsSchema } from "./humanitec";
 import { humanitecConnectionService } from "./humanitec/humanitec-connection-service";
 import { ValidateLdapConnectionCredentialsSchema } from "./ldap";
 import { ValidateMsSqlConnectionCredentialsSchema } from "./mssql";
-import { ValidateOCIConnectionCredentialsSchema } from "./oci";
-import { ociConnectionService } from "./oci/oci-connection-service";
 import { ValidatePostgresConnectionCredentialsSchema } from "./postgres";
 import { ValidateTeamCityConnectionCredentialsSchema } from "./teamcity";
 import { teamcityConnectionService } from "./teamcity/teamcity-connection-service";
@@ -65,6 +66,7 @@ export type TAppConnectionServiceFactoryDep = {
   appConnectionDAL: TAppConnectionDALFactory;
   permissionService: Pick<TPermissionServiceFactory, "getOrgPermission">;
   kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
+  licenseService: Pick<TLicenseServiceFactory, "getPlan">;
 };
 
 export type TAppConnectionServiceFactory = ReturnType<typeof appConnectionServiceFactory>;
@@ -94,7 +96,8 @@ const VALIDATE_APP_CONNECTION_CREDENTIALS_MAP: Record<AppConnection, TValidateAp
 export const appConnectionServiceFactory = ({
   appConnectionDAL,
   permissionService,
-  kmsService
+  kmsService,
+  licenseService
 }: TAppConnectionServiceFactoryDep) => {
   const listAppConnectionsByOrg = async (actor: OrgServiceActor, app?: AppConnection) => {
     const { permission } = await permissionService.getOrgPermission(
@@ -191,6 +194,16 @@ export const appConnectionServiceFactory = ({
       OrgPermissionSubjects.AppConnections
     );
 
+    // Enterprise check
+    if (APP_CONNECTION_PLAN_MAP[app] === AppConnectionPlanType.Enterprise) {
+      const plan = await licenseService.getPlan(actor.orgId);
+      if (!plan.enterpriseAppConnections)
+        throw new BadRequestError({
+          message:
+            "Failed to create app connection due to plan restriction. Upgrade plan to access enterprise app connections."
+        });
+    }
+
     const validatedCredentials = await validateAppConnectionCredentials({
       app,
       credentials,
@@ -253,6 +266,16 @@ export const appConnectionServiceFactory = ({
 
     if (!appConnection) throw new NotFoundError({ message: `Could not find App Connection with ID ${connectionId}` });
 
+    // Enterprise check
+    if (APP_CONNECTION_PLAN_MAP[appConnection.app as AppConnection] === AppConnectionPlanType.Enterprise) {
+      const plan = await licenseService.getPlan(actor.orgId);
+      if (!plan.enterpriseAppConnections)
+        throw new BadRequestError({
+          message:
+            "Failed to update app connection due to plan restriction. Upgrade plan to access enterprise app connections."
+        });
+    }
+
     const { permission } = await permissionService.getOrgPermission(
       actor.type,
       actor.id,
@@ -399,6 +422,16 @@ export const appConnectionServiceFactory = ({
 
     if (!appConnection) throw new NotFoundError({ message: `Could not find App Connection with ID ${connectionId}` });
 
+    // Enterprise check
+    if (APP_CONNECTION_PLAN_MAP[app] === AppConnectionPlanType.Enterprise) {
+      const plan = await licenseService.getPlan(actor.orgId);
+      if (!plan.enterpriseAppConnections)
+        throw new BadRequestError({
+          message:
+            "Failed to connect app connection due to plan restriction. Upgrade plan to access enterprise app connections."
+        });
+    }
+
     const { permission: orgPermission } = await permissionService.getOrgPermission(
       actor.type,
       actor.id,
@@ -468,6 +501,6 @@ export const appConnectionServiceFactory = ({
     hcvault: hcVaultConnectionService(connectAppConnectionById),
     windmill: windmillConnectionService(connectAppConnectionById),
     teamcity: teamcityConnectionService(connectAppConnectionById),
-    oci: ociConnectionService(connectAppConnectionById)
+    oci: ociConnectionService(connectAppConnectionById, licenseService)
   };
 };

backend/src/services/app-connection/app-connection-types.ts

@@ -2,6 +2,12 @@ import { TAppConnectionDALFactory } from "@app/services/app-connection/app-conne
 import { TSqlConnectionConfig } from "@app/services/app-connection/shared/sql/sql-connection-types";
 import { SecretSync } from "@app/services/secret-sync/secret-sync-enums";
 
+import {
+  TOCIConnection,
+  TOCIConnectionConfig,
+  TOCIConnectionInput,
+  TValidateOCIConnectionCredentialsSchema
+} from "../../ee/services/app-connections/oci";
 import { AWSRegion } from "./app-connection-enums";
 import {
   TAuth0Connection,
@@ -76,12 +82,6 @@ import {
   TValidateLdapConnectionCredentialsSchema
 } from "./ldap";
 import { TMsSqlConnection, TMsSqlConnectionInput, TValidateMsSqlConnectionCredentialsSchema } from "./mssql";
-import {
-  TOCIConnection,
-  TOCIConnectionConfig,
-  TOCIConnectionInput,
-  TValidateOCIConnectionCredentialsSchema
-} from "./oci";
 import {
   TPostgresConnection,
   TPostgresConnectionInput,

backend/src/services/app-connection/oci/index.ts

@@ -1,4 +0,0 @@
-export * from "./oci-connection-enums";
-export * from "./oci-connection-fns";
-export * from "./oci-connection-schemas";
-export * from "./oci-connection-types";

backend/src/services/app-connection/oci/oci-connection-enums.ts

@@ -1,3 +0,0 @@
-export enum OCIConnectionMethod {
-  AccessKey = "access-key"
-}

backend/src/services/app-connection/oci/oci-connection-fns.ts

@@ -1,139 +0,0 @@
-import { common, identity, keymanagement } from "oci-sdk";
-
-import { BadRequestError } from "@app/lib/errors";
-import { AppConnection } from "@app/services/app-connection/app-connection-enums";
-
-import { OCIConnectionMethod } from "./oci-connection-enums";
-import { TOCIConnection, TOCIConnectionConfig } from "./oci-connection-types";
-
-export const getOCIProvider = async (config: TOCIConnectionConfig) => {
-  const {
-    credentials: { fingerprint, privateKey, region, tenancyOcid, userOcid }
-  } = config;
-
-  const provider = new common.SimpleAuthenticationDetailsProvider(
-    tenancyOcid,
-    userOcid,
-    fingerprint,
-    privateKey,
-    null,
-    common.Region.fromRegionId(region)
-  );
-
-  return provider;
-};
-
-export const getOCIConnectionListItem = () => {
-  return {
-    name: "OCI" as const,
-    app: AppConnection.OCI as const,
-    methods: Object.values(OCIConnectionMethod) as [OCIConnectionMethod.AccessKey]
-  };
-};
-
-export const validateOCIConnectionCredentials = async (config: TOCIConnectionConfig) => {
-  const provider = await getOCIProvider(config);
-
-  try {
-    const identityClient = new identity.IdentityClient({
-      authenticationDetailsProvider: provider
-    });
-
-    // Get user details - a lightweight call that validates all credentials
-    await identityClient.getUser({ userId: config.credentials.userOcid });
-  } catch (error: unknown) {
-    if (error instanceof Error) {
-      throw new BadRequestError({
-        message: `Failed to validate credentials: ${error.message || "Unknown error"}`
-      });
-    }
-    throw new BadRequestError({
-      message: "Unable to validate connection: verify credentials"
-    });
-  }
-
-  return config.credentials;
-};
-
-export const listOCICompartments = async (appConnection: TOCIConnection) => {
-  const provider = await getOCIProvider(appConnection);
-
-  const identityClient = new identity.IdentityClient({ authenticationDetailsProvider: provider });
-  const keyManagementClient = new keymanagement.KmsVaultClient({
-    authenticationDetailsProvider: provider
-  });
-
-  const rootCompartment = await identityClient
-    .getTenancy({
-      tenancyId: appConnection.credentials.tenancyOcid
-    })
-    .then((response) => ({
-      ...response.tenancy,
-      id: appConnection.credentials.tenancyOcid,
-      name: response.tenancy.name ? `${response.tenancy.name} (root)` : "root"
-    }));
-
-  const compartments = await identityClient.listCompartments({
-    compartmentId: appConnection.credentials.tenancyOcid,
-    compartmentIdInSubtree: true,
-    accessLevel: identity.requests.ListCompartmentsRequest.AccessLevel.Any,
-    lifecycleState: identity.models.Compartment.LifecycleState.Active
-  });
-
-  const allCompartments = [rootCompartment, ...compartments.items];
-  const filteredCompartments = [];
-
-  for await (const compartment of allCompartments) {
-    try {
-      // Check if user can list vaults in this compartment
-      await keyManagementClient.listVaults({
-        compartmentId: compartment.id,
-        limit: 1
-      });
-
-      filteredCompartments.push(compartment);
-    } catch (error) {
-      // Do nothing
-    }
-  }
-
-  return filteredCompartments;
-};
-
-export const listOCIVaults = async (appConnection: TOCIConnection, compartmentOcid: string) => {
-  const provider = await getOCIProvider(appConnection);
-
-  const keyManagementClient = new keymanagement.KmsVaultClient({
-    authenticationDetailsProvider: provider
-  });
-
-  const vaults = await keyManagementClient.listVaults({
-    compartmentId: compartmentOcid
-  });
-
-  return vaults.items.filter((v) => v.lifecycleState === keymanagement.models.Vault.LifecycleState.Active);
-};
-
-export const listOCIVaultKeys = async (appConnection: TOCIConnection, compartmentOcid: string, vaultOcid: string) => {
-  const provider = await getOCIProvider(appConnection);
-
-  const kmsVaultClient = new keymanagement.KmsVaultClient({
-    authenticationDetailsProvider: provider
-  });
-
-  const vault = await kmsVaultClient.getVault({
-    vaultId: vaultOcid
-  });
-
-  const keyManagementClient = new keymanagement.KmsManagementClient({
-    authenticationDetailsProvider: provider
-  });
-
-  keyManagementClient.endpoint = vault.vault.managementEndpoint;
-
-  const keys = await keyManagementClient.listKeys({
-    compartmentId: compartmentOcid
-  });
-
-  return keys.items.filter((v) => v.lifecycleState === keymanagement.models.KeySummary.LifecycleState.Enabled);
-};

backend/src/services/app-connection/oci/oci-connection-schemas.ts

@@ -1,65 +0,0 @@
-import z from "zod";
-
-import { AppConnections } from "@app/lib/api-docs";
-import { AppConnection } from "@app/services/app-connection/app-connection-enums";
-import {
-  BaseAppConnectionSchema,
-  GenericCreateAppConnectionFieldsSchema,
-  GenericUpdateAppConnectionFieldsSchema
-} from "@app/services/app-connection/app-connection-schemas";
-
-import { OCIConnectionMethod } from "./oci-connection-enums";
-
-export const OCIConnectionAccessTokenCredentialsSchema = z.object({
-  userOcid: z.string().trim().min(1, "User OCID required").describe(AppConnections.CREDENTIALS.OCI.userOcid),
-  tenancyOcid: z.string().trim().min(1, "Tenancy OCID required").describe(AppConnections.CREDENTIALS.OCI.tenancyOcid),
-  region: z.string().trim().min(1, "Region required").describe(AppConnections.CREDENTIALS.OCI.region),
-  fingerprint: z.string().trim().min(1, "Fingerprint required").describe(AppConnections.CREDENTIALS.OCI.fingerprint),
-  privateKey: z.string().trim().min(1, "Private Key required").describe(AppConnections.CREDENTIALS.OCI.privateKey)
-});
-
-const BaseOCIConnectionSchema = BaseAppConnectionSchema.extend({ app: z.literal(AppConnection.OCI) });
-
-export const OCIConnectionSchema = BaseOCIConnectionSchema.extend({
-  method: z.literal(OCIConnectionMethod.AccessKey),
-  credentials: OCIConnectionAccessTokenCredentialsSchema
-});
-
-export const SanitizedOCIConnectionSchema = z.discriminatedUnion("method", [
-  BaseOCIConnectionSchema.extend({
-    method: z.literal(OCIConnectionMethod.AccessKey),
-    credentials: OCIConnectionAccessTokenCredentialsSchema.pick({
-      userOcid: true,
-      tenancyOcid: true,
-      region: true,
-      fingerprint: true
-    })
-  })
-]);
-
-export const ValidateOCIConnectionCredentialsSchema = z.discriminatedUnion("method", [
-  z.object({
-    method: z.literal(OCIConnectionMethod.AccessKey).describe(AppConnections.CREATE(AppConnection.OCI).method),
-    credentials: OCIConnectionAccessTokenCredentialsSchema.describe(
-      AppConnections.CREATE(AppConnection.OCI).credentials
-    )
-  })
-]);
-
-export const CreateOCIConnectionSchema = ValidateOCIConnectionCredentialsSchema.and(
-  GenericCreateAppConnectionFieldsSchema(AppConnection.OCI)
-);
-
-export const UpdateOCIConnectionSchema = z
-  .object({
-    credentials: OCIConnectionAccessTokenCredentialsSchema.optional().describe(
-      AppConnections.UPDATE(AppConnection.OCI).credentials
-    )
-  })
-  .and(GenericUpdateAppConnectionFieldsSchema(AppConnection.OCI));
-
-export const OCIConnectionListItemSchema = z.object({
-  name: z.literal("OCI"),
-  app: z.literal(AppConnection.OCI),
-  methods: z.nativeEnum(OCIConnectionMethod).array()
-});

backend/src/services/app-connection/oci/oci-connection-service.ts

@@ -1,70 +0,0 @@
-import { logger } from "@app/lib/logger";
-import { OrgServiceActor } from "@app/lib/types";
-
-import { AppConnection } from "../app-connection-enums";
-import { listOCICompartments, listOCIVaultKeys, listOCIVaults } from "./oci-connection-fns";
-import { TOCIConnection } from "./oci-connection-types";
-
-type TGetAppConnectionFunc = (
-  app: AppConnection,
-  connectionId: string,
-  actor: OrgServiceActor
-) => Promise<TOCIConnection>;
-
-type TListOCIVaultsDTO = {
-  connectionId: string;
-  compartmentOcid: string;
-};
-
-type TListOCIVaultKeysDTO = {
-  connectionId: string;
-  compartmentOcid: string;
-  vaultOcid: string;
-};
-
-export const ociConnectionService = (getAppConnection: TGetAppConnectionFunc) => {
-  const listCompartments = async (connectionId: string, actor: OrgServiceActor) => {
-    const appConnection = await getAppConnection(AppConnection.OCI, connectionId, actor);
-
-    try {
-      const compartments = await listOCICompartments(appConnection);
-      return compartments;
-    } catch (error) {
-      logger.error(error, "Failed to establish connection with OCI");
-      return [];
-    }
-  };
-
-  const listVaults = async ({ connectionId, compartmentOcid }: TListOCIVaultsDTO, actor: OrgServiceActor) => {
-    const appConnection = await getAppConnection(AppConnection.OCI, connectionId, actor);
-
-    try {
-      const vaults = await listOCIVaults(appConnection, compartmentOcid);
-      return vaults;
-    } catch (error) {
-      logger.error(error, "Failed to establish connection with OCI");
-      return [];
-    }
-  };
-
-  const listVaultKeys = async (
-    { connectionId, compartmentOcid, vaultOcid }: TListOCIVaultKeysDTO,
-    actor: OrgServiceActor
-  ) => {
-    const appConnection = await getAppConnection(AppConnection.OCI, connectionId, actor);
-
-    try {
-      const keys = await listOCIVaultKeys(appConnection, compartmentOcid, vaultOcid);
-      return keys;
-    } catch (error) {
-      logger.error(error, "Failed to establish connection with OCI");
-      return [];
-    }
-  };
-
-  return {
-    listCompartments,
-    listVaults,
-    listVaultKeys
-  };
-};

backend/src/services/app-connection/oci/oci-connection-types.ts

@@ -1,22 +0,0 @@
-import z from "zod";
-
-import { DiscriminativePick } from "@app/lib/types";
-
-import { AppConnection } from "../app-connection-enums";
-import {
-  CreateOCIConnectionSchema,
-  OCIConnectionSchema,
-  ValidateOCIConnectionCredentialsSchema
-} from "./oci-connection-schemas";
-
-export type TOCIConnection = z.infer<typeof OCIConnectionSchema>;
-
-export type TOCIConnectionInput = z.infer<typeof CreateOCIConnectionSchema> & {
-  app: AppConnection.OCI;
-};
-
-export type TValidateOCIConnectionCredentialsSchema = typeof ValidateOCIConnectionCredentialsSchema;
-
-export type TOCIConnectionConfig = DiscriminativePick<TOCIConnectionInput, "method" | "app" | "credentials"> & {
-  orgId: string;
-};