Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

feat: add bridge between legacy and global approval system

adilson917955fdcd8f
diff --git a/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts b/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts
new file mode 100644
index 0000000000..ae2d759f3a
--- /dev/null
+++ b/backend/e2e-test/routes/v1/access-approval-global-request-routing.spec.ts
@@ -0,0 +1,161 @@
+import { Knex } from "knex";
+
+import { TableName } from "@app/db/schemas";
+import { seedData1 } from "@app/db/seed-data";
+import { ApproverType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+import { EnforcementLevel } from "@app/lib/types";
+
+const getDb = () => (globalThis as unknown as { testDb: Knex }).testDb;
+
+const GLOBAL_REQUEST_UNSUPPORTED_MESSAGE =
+ "Secret access approval requests are not supported on the global approval system yet";
+
+// Both systems share the seeded project and environment, so every policy this
+// file creates is removed after each test to keep later specs unaffected.
+const legacyPolicyIds: string[] = [];
+const globalPolicyIds: string[] = [];
+
+// The create route always writes to the global tables now, so a legacy policy
+// has to be seeded straight into the legacy tables.
+const createLegacyPolicy = async (dto: { name: string; secretPath: string }) => {
+ const db = getDb();
+ const env = await db(TableName.Environment)
+ .where({ projectId: seedData1.project.id, slug: seedData1.environment.slug })
+ .first();
+ if (!env) throw new Error(`seed environment '${seedData1.environment.slug}' not found`);
+
+ const [policy] = await db(TableName.AccessApprovalPolicy)
+ .insert({
+ name: dto.name,
+ secretPath: dto.secretPath,
+ envId: env.id,
+ approvals: 1,
+ enforcementLevel: EnforcementLevel.Hard,
+ allowedSelfApprovals: true
+ })
+ .returning("*");
+ legacyPolicyIds.push(policy.id);
+
+ await db(TableName.AccessApprovalPolicyEnvironment).insert({ policyId: policy.id, envId: env.id });
+ await db(TableName.AccessApprovalPolicyApprover).insert({
+ policyId: policy.id,
+ approverUserId: seedData1.id,
+ sequence: 1,
+ approvalsRequired: 1
+ });
+
+ return policy;
+};
+
+const createGlobalPolicy = async (dto: { name: string; secretPath: string }) => {
+ const res = await testServer.inject({
+ method: "POST",
+ url: "/api/v1/access-approvals/policies",
+ headers: {
+ authorization: `Bearer ${jwtAuthToken}`
+ },
+ body: {
+ projectSlug: seedData1.project.slug,
+ environment: seedData1.environment.slug,
+ name: dto.name,
+ secretPath: dto.secretPath,
+ approvers: [{ type: ApproverType.User, id: seedData1.id }],
+ approvals: 1
+ }
+ });
+
+ if (res.statusCode === 200) {
+ globalPolicyIds.push(res.json().approval.id);
+ }
+ return res;
+};
+
+const createAccessRequest = (secretPath: string) =>
+ testServer.inject({
+ method: "POST",
+ url: `/api/v1/access-approvals/requests?projectSlug=${seedData1.project.slug}`,
+ headers: {
+ authorization: `Bearer ${jwtAuthToken}`
+ },
+ body: {
+ permissions: [
+ ["read", "secrets", { environment: seedData1.environment.slug, secretPath: { $glob: secretPath } }]
+ ],
+ isTemporary: false
+ }
+ });
+
+describe("Access approval request routing", () => {
+ afterEach(async () => {
+ const db = getDb();
+ const legacyIds = legacyPolicyIds.splice(0);
+ const globalIds = globalPolicyIds.splice(0);
+
+ if (legacyIds.length) {
+ await db(TableName.AccessApprovalRequest).whereIn("policyId", legacyIds).del();
+ await db(TableName.AccessApprovalPolicyApprover).whereIn("policyId", legacyIds).del();
+ await db(TableName.AccessApprovalPolicyEnvironment).whereIn("policyId", legacyIds).del();
+ await db(TableName.AccessApprovalPolicy).whereIn("id", legacyIds).del();
+ }
+ if (globalIds.length) {
+ await db(TableName.ApprovalPolicies).whereIn("id", globalIds).del();
+ }
+ });
+
+ test("A global policy cannot be created for an env and path a legacy policy already covers", async () => {
+ const db = getDb();
+ const secretPath = "/routing-conflict";
+ await createLegacyPolicy({ name: "routing-conflict-legacy", secretPath });
+
+ const res = await createGlobalPolicy({ name: "routing-conflict-global", secretPath });
+
+ expect(res.statusCode).toBe(400);
+ expect(res.json().message).toContain(`already exists in environment '${seedData1.environment.slug}'`);
+
+ const globalRows = await db(TableName.ApprovalPolicySecretEnvironment).where({ secretPath });
+ expect(globalRows).toHaveLength(0);
+ });
+
+ test("A request against a legacy policy is created on the legacy system", async () => {
+ const db = getDb();
+ const secretPath = "/routing-legacy";
+ const legacyPolicy = await createLegacyPolicy({ name: "routing-legacy", secretPath });
+
+ const res = await createAccessRequest(secretPath);
+
+ expect(res.statusCode).toBe(200);
+ const { approval } = res.json();
+ expect(approval.policyId).toBe(legacyPolicy.id);
+
+ const rows = await db(TableName.AccessApprovalRequest).where({ policyId: legacyPolicy.id });
+ expect(rows).toHaveLength(1);
+ expect(rows[0].id).toBe(approval.id);
+ });
+
+ test("A request against a global policy is routed to the global system", async () => {
+ const db = getDb();
+ const secretPath = "/routing-global";
+ const createRes = await createGlobalPolicy({ name: "routing-global", secretPath });
+ expect(createRes.statusCode).toBe(200);
+
+ const globalPolicyRow = await db(TableName.ApprovalPolicies).where({ id: createRes.json().approval.id }).first();
+ expect(globalPolicyRow?.type).toBe("secret-access");
+
+ const res = await createAccessRequest(secretPath);
+
+ expect(res.statusCode).toBe(400);
+ expect(res.json().message).toBe(GLOBAL_REQUEST_UNSUPPORTED_MESSAGE);
+
+ const legacyRows = await db(TableName.AccessApprovalRequest)
+ .whereRaw(`"permissions"::text like ?`, [`%${secretPath}%`])
+ .select("id");
+ expect(legacyRows).toHaveLength(0);
+ });
+
+ test("A request with no policy on either system is rejected", async () => {
+ const res = await createAccessRequest("/routing-none");
+
+ expect(res.statusCode).toBe(404);
+ expect(res.json().message).toContain("No policy in environment");
+ });
+});
diff --git a/backend/src/ee/services/access-approval-request/access-approval-request-service.ts b/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
index 3d3bd10639..606bce895b 100644
--- a/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
+++ b/backend/src/ee/services/access-approval-request/access-approval-request-service.ts
@@ -16,12 +16,14 @@ import { triggerWorkflowIntegrationNotification } from "@app/lib/workflow-integr
import { TriggerFeature } from "@app/lib/workflow-integrations/types";
import { QueueJobs, QueueName, TQueueServiceFactory } from "@app/queue";
import { TAdditionalPrivilegeDALFactory } from "@app/services/additional-privilege/additional-privilege-dal";
+import { TApprovalPolicySecretEnvironmentDALFactory } from "@app/services/approval-policy/approval-policy-dal";
import { ActorType } from "@app/services/auth/auth-type";
import { TKmsServiceFactory } from "@app/services/kms/kms-service";
import { TMicrosoftTeamsServiceFactory } from "@app/services/microsoft-teams/microsoft-teams-service";
import { TProjectMicrosoftTeamsConfigDALFactory } from "@app/services/microsoft-teams/project-microsoft-teams-config-dal";
import { TProjectDALFactory } from "@app/services/project/project-dal";
import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
+import { TSecretAccessApprovalBridgeServiceFactory } from "@app/services/secret-access-approval-bridge/secret-access-approval-bridge-service";
import { TProjectSlackConfigDALFactory } from "@app/services/slack/project-slack-config-dal";
import { SmtpTemplates, TSmtpService } from "@app/services/smtp/smtp-service";
import { TUserDALFactory } from "@app/services/user/user-dal";
@@ -70,6 +72,11 @@ type TSecretApprovalRequestServiceFactoryDep = {
| "getCount"
>;
accessApprovalPolicyDAL: Pick<TAccessApprovalPolicyDALFactory, "findOne" | "find" | "findLastValidPolicy">;
+ approvalPolicySecretEnvironmentDAL: Pick<
+ TApprovalPolicySecretEnvironmentDALFactory,
+ "findPolicyByEnvIdsAndSecretPath"
+ >;
+ secretAccessApprovalBridge: Pick<TSecretAccessApprovalBridgeServiceFactory, "createAccessApprovalRequest">;
accessApprovalRequestReviewerDAL: Pick<
TAccessApprovalRequestReviewerDALFactory,
"create" | "find" | "findOne" | "transaction" | "delete"
@@ -97,6 +104,8 @@ export const accessApprovalRequestServiceFactory = ({
accessApprovalRequestReviewerDAL,
accessApprovalPolicyDAL,
accessApprovalPolicyApproverDAL,
+ approvalPolicySecretEnvironmentDAL,
+ secretAccessApprovalBridge,
additionalPrivilegeDAL,
smtpService,
userDAL,
@@ -219,6 +228,31 @@ export const accessApprovalRequestServiceFactory = ({
);
};
+ const $usesGlobalApprovalBridge = async ({
+ envId,
+ secretPath
+ }: {
+ envId: string;
+ secretPath: string;
+ }): Promise<
+ | { usesGlobalBridge: true; globalPolicy: { id: string; name: string } }
+ | {
+ usesGlobalBridge: false;
+ legacyPolicy: Awaited<ReturnType<TAccessApprovalPolicyDALFactory["findLastValidPolicy"]>>;
+ }
+ > => {
+ const [legacyPolicy, globalPolicy] = await Promise.all([
+ accessApprovalPolicyDAL.findLastValidPolicy({ envId, secretPath }),
+ approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdsAndSecretPath({ envIds: [envId], secretPath })
+ ]);
+
+ if (globalPolicy) {
+ return { usesGlobalBridge: true, globalPolicy: { id: globalPolicy.policyId, name: globalPolicy.policyName } };
+ }
+
+ return { usesGlobalBridge: false, legacyPolicy };
+ };
+
const createAccessApprovalRequest: TAccessApprovalRequestServiceFactory["createAccessApprovalRequest"] = async ({
isTemporary,
temporaryRange,
@@ -256,10 +290,24 @@ export const accessApprovalRequestServiceFactory = ({
if (!environment) throw new NotFoundError({ message: `Environment with slug '${envSlug}' not found` });
- const policy = await accessApprovalPolicyDAL.findLastValidPolicy({
- envId: environment.id,
- secretPath
- });
+ const approvalBridge = await $usesGlobalApprovalBridge({ envId: environment.id, secretPath });
+
+ if (approvalBridge.usesGlobalBridge) {
+ return secretAccessApprovalBridge.createAccessApprovalRequest({
+ policy: approvalBridge.globalPolicy,
+ projectId: project.id,
+ envId: environment.id,
+ envSlug,
+ secretPath,
+ requestedByUserId: actorId,
+ permissions: requestedPermissions,
+ isTemporary,
+ temporaryRange,
+ note
+ });
+ }
+
+ const policy = routing.legacyPolicy;
if (!policy) {
throw new NotFoundError({
message: `No policy in environment with slug '${environment.slug}' and with secret path '${secretPath}' was found.`
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 8d9f92c7dd..8538cd2489 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -2636,6 +2636,8 @@ export const registerRoutes = async (
permissionService,
accessApprovalRequestReviewerDAL,
accessApprovalPolicyDAL,
+ approvalPolicySecretEnvironmentDAL,
+ secretAccessApprovalBridge: secretAccessApprovalBridgeService,
accessApprovalRequestDAL,
projectEnvDAL,
userDAL,
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts
index 1b4fd72150..9d951707e7 100644
--- a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-service.ts
@@ -11,6 +11,7 @@ import { ApprovalPolicyType } from "@app/services/approval-policy/approval-polic
import { secretAccessApprovalPolicyExists } from "./secret-access-approval-bridge-fns";
import {
TCreateSecretAccessApprovalPolicyDTO,
+ TCreateSecretAccessApprovalRequestDTO,
TSecretAccessApprovalBridgeServiceFactoryDep
} from "./secret-access-approval-bridge-types";
@@ -280,5 +281,11 @@ export const secretAccessApprovalBridgeServiceFactory = ({
};
};
- return { createAccessApprovalPolicy };
+ const createAccessApprovalRequest: (dto: TCreateSecretAccessApprovalRequestDTO) => Promise<never> = async () => {
+ throw new BadRequestError({
+ message: "Secret access approval requests are not supported on the global approval system yet"
+ });
+ };
+
+ return { createAccessApprovalPolicy, createAccessApprovalRequest };
};
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts
index f145eb83a2..d7c3308309 100644
--- a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-types.ts
@@ -29,3 +29,16 @@ export type TSecretAccessApprovalBridgeServiceFactoryDep = {
};
export type TCreateSecretAccessApprovalPolicyDTO = TCreateAccessApprovalPolicy;
+
+export type TCreateSecretAccessApprovalRequestDTO = {
+ policy: { id: string; name: string };
+ projectId: string;
+ envId: string;
+ envSlug: string;
+ secretPath: string;
+ requestedByUserId: string;
+ permissions: unknown;
+ isTemporary: boolean;
+ temporaryRange?: string;
+ note?: string;
+};