Skip to content

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

feat: add create new policy into the global policy

adilson9083ff048fc8
diff --git a/backend/src/@types/fastify.d.ts b/backend/src/@types/fastify.d.ts
index 9c0efc4678..333a010c67 100644
--- a/backend/src/@types/fastify.d.ts
+++ b/backend/src/@types/fastify.d.ts
@@ -168,6 +168,7 @@ import { TReminderServiceFactory } from "@app/services/reminder/reminder-types";
import { TResourceMetadataServiceFactory } from "@app/services/resource-metadata/resource-metadata-service";
import { TRoleServiceFactory } from "@app/services/role/role-service";
import { TSecretServiceFactory } from "@app/services/secret/secret-service";
+import { TSecretAccessApprovalBridgeServiceFactory } from "@app/services/secret-access-approval-bridge/secret-access-approval-bridge-service";
import { TSecretBlindIndexServiceFactory } from "@app/services/secret-blind-index/secret-blind-index-service";
import { TSecretFolderServiceFactory } from "@app/services/secret-folder/secret-folder-service";
import { TSecretImportServiceFactory } from "@app/services/secret-import/secret-import-service";
@@ -345,6 +346,7 @@ declare module "fastify" {
identitySpiffeAuth: TIdentitySpiffeAuthServiceFactory;
identityLdapAuth: TIdentityLdapAuthServiceFactory;
accessApprovalPolicy: TAccessApprovalPolicyServiceFactory;
+ secretAccessApprovalBridge: TSecretAccessApprovalBridgeServiceFactory;
accessApprovalRequest: TAccessApprovalRequestServiceFactory;
secretApprovalPolicy: TSecretApprovalPolicyServiceFactory;
secretApprovalRequest: TSecretApprovalRequestServiceFactory;
diff --git a/backend/src/@types/knex.d.ts b/backend/src/@types/knex.d.ts
index 62db78d2c4..3c91e6989f 100644
--- a/backend/src/@types/knex.d.ts
+++ b/backend/src/@types/knex.d.ts
@@ -77,6 +77,9 @@ import {
TApprovalPolicyBypassers,
TApprovalPolicyBypassersInsert,
TApprovalPolicyBypassersUpdate,
+ TApprovalPolicySecretEnvironments,
+ TApprovalPolicySecretEnvironmentsInsert,
+ TApprovalPolicySecretEnvironmentsUpdate,
TApprovalPolicyStepApprovers,
TApprovalPolicyStepApproversInsert,
TApprovalPolicyStepApproversUpdate,
@@ -1924,6 +1927,11 @@ declare module "knex/types/tables" {
TApprovalPolicyBypassersInsert,
TApprovalPolicyBypassersUpdate
>;
+ [TableName.ApprovalPolicySecretEnvironment]: KnexOriginal.CompositeTableType<
+ TApprovalPolicySecretEnvironments,
+ TApprovalPolicySecretEnvironmentsInsert,
+ TApprovalPolicySecretEnvironmentsUpdate
+ >;
[TableName.ApprovalPolicyStepApprovers]: KnexOriginal.CompositeTableType<
TApprovalPolicyStepApprovers,
TApprovalPolicyStepApproversInsert,
diff --git a/backend/src/db/migrations/20260930120000_approval-policy-secret-environments.ts b/backend/src/db/migrations/20260930120000_approval-policy-secret-environments.ts
new file mode 100644
index 0000000000..1a8d310b77
--- /dev/null
+++ b/backend/src/db/migrations/20260930120000_approval-policy-secret-environments.ts
@@ -0,0 +1,30 @@
+import { Knex } from "knex";
+
+import { TableName } from "../schemas";
+import { createOnUpdateTrigger, dropOnUpdateTrigger } from "../utils";
+
+export async function up(knex: Knex): Promise<void> {
+ if (!(await knex.schema.hasTable(TableName.ApprovalPolicySecretEnvironment))) {
+ await knex.schema.createTable(TableName.ApprovalPolicySecretEnvironment, (t) => {
+ t.uuid("id", { primaryKey: true }).defaultTo(knex.fn.uuid());
+
+ t.uuid("policyId").notNullable().index();
+ t.foreign("policyId").references("id").inTable(TableName.ApprovalPolicies).onDelete("CASCADE");
+
+ t.uuid("envId").notNullable().index();
+ t.foreign("envId").references("id").inTable(TableName.Environment).onDelete("CASCADE");
+
+ t.string("secretPath").notNullable();
+
+ t.timestamps(true, true, true);
+ t.unique(["policyId", "envId"]);
+ });
+
+ await createOnUpdateTrigger(knex, TableName.ApprovalPolicySecretEnvironment);
+ }
+}
+
+export async function down(knex: Knex): Promise<void> {
+ await dropOnUpdateTrigger(knex, TableName.ApprovalPolicySecretEnvironment);
+ await knex.schema.dropTableIfExists(TableName.ApprovalPolicySecretEnvironment);
+}
diff --git a/backend/src/db/schemas/additional-privileges.ts b/backend/src/db/schemas/additional-privileges.ts
index 920f477496..a72d52c343 100644
--- a/backend/src/db/schemas/additional-privileges.ts
+++ b/backend/src/db/schemas/additional-privileges.ts
@@ -23,7 +23,8 @@ export const AdditionalPrivilegesSchema = z.object({
createdAt: z.date(),
updatedAt: z.date(),
folderId: z.string().uuid().nullable().optional(),
- role: z.string().nullable().optional()
+ role: z.string().nullable().optional(),
+ grantId: z.string().uuid().nullable().optional()
});
export type TAdditionalPrivileges = z.infer<typeof AdditionalPrivilegesSchema>;
diff --git a/backend/src/db/schemas/approval-policy-secret-environments.ts b/backend/src/db/schemas/approval-policy-secret-environments.ts
new file mode 100644
index 0000000000..f571baea1f
--- /dev/null
+++ b/backend/src/db/schemas/approval-policy-secret-environments.ts
@@ -0,0 +1,26 @@
+// Code generated by automation script, DO NOT EDIT.
+// Automated by pulling database and generating zod schema
+// To update. Just run npm run generate:schema
+// Written by akhilmhdh.
+
+import { z } from "zod";
+
+import { TImmutableDBKeys } from "./models";
+
+export const ApprovalPolicySecretEnvironmentsSchema = z.object({
+ id: z.string().uuid(),
+ policyId: z.string().uuid(),
+ envId: z.string().uuid(),
+ secretPath: z.string(),
+ createdAt: z.date(),
+ updatedAt: z.date()
+});
+
+export type TApprovalPolicySecretEnvironments = z.infer<typeof ApprovalPolicySecretEnvironmentsSchema>;
+export type TApprovalPolicySecretEnvironmentsInsert = Omit<
+ z.input<typeof ApprovalPolicySecretEnvironmentsSchema>,
+ TImmutableDBKeys
+>;
+export type TApprovalPolicySecretEnvironmentsUpdate = Partial<
+ Omit<z.input<typeof ApprovalPolicySecretEnvironmentsSchema>, TImmutableDBKeys>
+>;
diff --git a/backend/src/db/schemas/index.ts b/backend/src/db/schemas/index.ts
index 212f1056c9..f12aba078b 100644
--- a/backend/src/db/schemas/index.ts
+++ b/backend/src/db/schemas/index.ts
@@ -23,6 +23,7 @@ export * from "./app-connection-credential-rotations";
export * from "./app-connections";
export * from "./approval-policies";
export * from "./approval-policy-bypassers";
+export * from "./approval-policy-secret-environments";
export * from "./approval-policy-step-approvers";
export * from "./approval-policy-steps";
export * from "./approval-request-approvals";
diff --git a/backend/src/db/schemas/models.ts b/backend/src/db/schemas/models.ts
index 635ff9e65e..2a2951929f 100644
--- a/backend/src/db/schemas/models.ts
+++ b/backend/src/db/schemas/models.ts
@@ -321,6 +321,7 @@ export enum TableName {
ApprovalPolicySteps = "approval_policy_steps",
ApprovalPolicyStepApprovers = "approval_policy_step_approvers",
ApprovalPolicyBypassers = "approval_policy_bypassers",
+ ApprovalPolicySecretEnvironment = "approval_policy_secret_environments",
ApprovalRequests = "approval_requests",
ApprovalRequestSteps = "approval_request_steps",
ApprovalRequestStepEligibleApprovers = "approval_request_step_eligible_approvers",
diff --git a/backend/src/ee/routes/v1/access-approval-policy-router.ts b/backend/src/ee/routes/v1/access-approval-policy-router.ts
index 944ac35f84..3ac13d5a34 100644
--- a/backend/src/ee/routes/v1/access-approval-policy-router.ts
+++ b/backend/src/ee/routes/v1/access-approval-policy-router.ts
@@ -148,7 +148,7 @@ export const registerAccessApprovalPolicyRouter = async (server: FastifyZodProvi
},
onRequest: verifyAuth([AuthMode.JWT, AuthMode.IDENTITY_ACCESS_TOKEN]),
handler: async (req) => {
- const approval = await server.services.accessApprovalPolicy.createAccessApprovalPolicy({
+ const approval = await server.services.secretAccessApprovalBridge.createAccessApprovalPolicy({
actor: req.permission.type,
actorId: req.permission.id,
actorAuthMethod: req.permission.authMethod,
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 8720b9fb93..8d9f92c7dd 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -259,6 +259,7 @@ import {
import {
approvalPolicyBypassersDALFactory,
approvalPolicyDALFactory,
+ approvalPolicySecretEnvironmentDALFactory,
approvalPolicyStepApproversDALFactory,
approvalPolicyStepsDALFactory
} from "@app/services/approval-policy/approval-policy-dal";
@@ -503,6 +504,7 @@ import { secretQueueFactory } from "@app/services/secret/secret-queue";
import { secretServiceFactory } from "@app/services/secret/secret-service";
import { secretVersionDALFactory } from "@app/services/secret/secret-version-dal";
import { secretVersionTagDALFactory } from "@app/services/secret/secret-version-tag-dal";
+import { secretAccessApprovalBridgeServiceFactory } from "@app/services/secret-access-approval-bridge/secret-access-approval-bridge-service";
import { secretBlindIndexDALFactory } from "@app/services/secret-blind-index/secret-blind-index-dal";
import { secretBlindIndexServiceFactory } from "@app/services/secret-blind-index/secret-blind-index-service";
import { secretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";
@@ -1797,6 +1799,7 @@ export const registerRoutes = async (
const approvalPolicyStepsDAL = approvalPolicyStepsDALFactory(db);
const approvalPolicyStepApproversDAL = approvalPolicyStepApproversDALFactory(db);
const approvalPolicyBypassersDAL = approvalPolicyBypassersDALFactory(db);
+ const approvalPolicySecretEnvironmentDAL = approvalPolicySecretEnvironmentDALFactory(db);
const approvalRequestApprovalsDAL = approvalRequestApprovalsDALFactory(db);
const orgGatewayConfigV2DAL = orgGatewayConfigV2DalFactory(db);
@@ -2615,6 +2618,19 @@ export const registerRoutes = async (
additionalPrivilegeDAL
});
+ const secretAccessApprovalBridgeService = secretAccessApprovalBridgeServiceFactory({
+ projectDAL,
+ permissionService,
+ projectEnvDAL,
+ userDAL,
+ accessApprovalPolicyDAL,
+ approvalPolicyDAL,
+ approvalPolicyStepsDAL,
+ approvalPolicyStepApproversDAL,
+ approvalPolicyBypassersDAL,
+ approvalPolicySecretEnvironmentDAL
+ });
+
const accessApprovalRequestService = accessApprovalRequestServiceFactory({
projectDAL,
permissionService,
@@ -4333,6 +4349,7 @@ export const registerRoutes = async (
identitySpiffeAuth: identitySpiffeAuthService,
identityLdapAuth: identityLdapAuthService,
accessApprovalPolicy: accessApprovalPolicyService,
+ secretAccessApprovalBridge: secretAccessApprovalBridgeService,
accessApprovalRequest: accessApprovalRequestService,
secretApprovalPolicy: secretApprovalPolicyService,
secretApprovalRequest: secretApprovalRequestService,
diff --git a/backend/src/services/approval-policy/approval-policy-dal.ts b/backend/src/services/approval-policy/approval-policy-dal.ts
index 9b3f044403..f106374386 100644
--- a/backend/src/services/approval-policy/approval-policy-dal.ts
+++ b/backend/src/services/approval-policy/approval-policy-dal.ts
@@ -519,3 +519,38 @@ export const approvalPolicyBypassersDALFactory = (db: TDbClient) => {
const orm = ormify(db, TableName.ApprovalPolicyBypassers);
return orm;
};
+
+// Approval Policy Secret Environments
+export type TApprovalPolicySecretEnvironmentDALFactory = ReturnType<typeof approvalPolicySecretEnvironmentDALFactory>;
+export const approvalPolicySecretEnvironmentDALFactory = (db: TDbClient) => {
+ const orm = ormify(db, TableName.ApprovalPolicySecretEnvironment);
+
+ const findPolicyByEnvIdsAndSecretPath = async (
+ { envIds, secretPath }: { envIds: string[]; secretPath: string },
+ tx?: Knex
+ ) => {
+ try {
+ const doc = (await (tx || db.replicaNode())(TableName.ApprovalPolicySecretEnvironment)
+ .join(
+ TableName.ApprovalPolicies,
+ `${TableName.ApprovalPolicies}.id`,
+ `${TableName.ApprovalPolicySecretEnvironment}.policyId`
+ )
+ .where(`${TableName.ApprovalPolicies}.type`, ApprovalPolicyType.SecretAccess)
+ .whereIn(`${TableName.ApprovalPolicySecretEnvironment}.envId`, envIds)
+ .where(`${TableName.ApprovalPolicySecretEnvironment}.secretPath`, secretPath)
+ .select(
+ db.ref("id").withSchema(TableName.ApprovalPolicies).as("policyId"),
+ db.ref("name").withSchema(TableName.ApprovalPolicies).as("policyName"),
+ db.ref("envId").withSchema(TableName.ApprovalPolicySecretEnvironment)
+ )
+ .first()) as { policyId: string; policyName: string; envId: string } | undefined;
+
+ return doc;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "Find approval policy by env ids and secret path" });
+ }
+ };
+
+ return { ...orm, findPolicyByEnvIdsAndSecretPath };
+};
diff --git a/backend/src/services/approval-policy/approval-policy-enums.ts b/backend/src/services/approval-policy/approval-policy-enums.ts
index 63dc671522..3157f5074d 100644
--- a/backend/src/services/approval-policy/approval-policy-enums.ts
+++ b/backend/src/services/approval-policy/approval-policy-enums.ts
@@ -1,7 +1,8 @@
export enum ApprovalPolicyType {
PamAccess = "pam-access",
CertRequest = "cert-request",
- CertCodeSigning = "cert-code-signing"
+ CertCodeSigning = "cert-code-signing",
+ SecretAccess = "secret-access"
}
export enum ApprovalPolicyScope {
diff --git a/backend/src/services/approval-policy/approval-policy-factory.ts b/backend/src/services/approval-policy/approval-policy-factory.ts
index 0462101424..7c64d94362 100644
--- a/backend/src/services/approval-policy/approval-policy-factory.ts
+++ b/backend/src/services/approval-policy/approval-policy-factory.ts
@@ -8,6 +8,7 @@ import {
import { certRequestPolicyFactory } from "./cert-request/cert-request-policy-factory";
import { codeSigningPolicyFactory } from "./code-signing/code-signing-policy-factory";
import { pamAccessPolicyFactory } from "./pam-access/pam-access-policy-factory";
+import { secretAccessPolicyFactory } from "./secret-access/secret-access-policy-factory";
type TApprovalPolicyFactoryImplementation = TApprovalResourceFactory<
TApprovalPolicyInputs,
@@ -18,5 +19,7 @@ type TApprovalPolicyFactoryImplementation = TApprovalResourceFactory<
export const APPROVAL_POLICY_FACTORY_MAP: Record<ApprovalPolicyType, TApprovalPolicyFactoryImplementation> = {
[ApprovalPolicyType.PamAccess]: pamAccessPolicyFactory as TApprovalPolicyFactoryImplementation,
[ApprovalPolicyType.CertRequest]: certRequestPolicyFactory as TApprovalPolicyFactoryImplementation,
- [ApprovalPolicyType.CertCodeSigning]: codeSigningPolicyFactory as TApprovalPolicyFactoryImplementation
+ [ApprovalPolicyType.CertCodeSigning]: codeSigningPolicyFactory as TApprovalPolicyFactoryImplementation,
+ // TODO(adilson): stub while secret access requests stay on the legacy tables; every routine throws
+ [ApprovalPolicyType.SecretAccess]: secretAccessPolicyFactory as TApprovalPolicyFactoryImplementation
};
diff --git a/backend/src/services/approval-policy/approval-policy-types.ts b/backend/src/services/approval-policy/approval-policy-types.ts
index b2e53cc3b8..1896695797 100644
--- a/backend/src/services/approval-policy/approval-policy-types.ts
+++ b/backend/src/services/approval-policy/approval-policy-types.ts
@@ -32,20 +32,38 @@ import {
TPamAccessRequest,
TPamAccessRequestData
} from "./pam-access/pam-access-policy-types";
-
-export type TApprovalPolicy = TPamAccessPolicy | TCertRequestPolicy | TCodeSigningPolicy;
-export type TApprovalPolicyInputs = TPamAccessPolicyInputs | TCertRequestPolicyInputs | TCodeSigningPolicyInputs;
+import {
+ TSecretAccessPolicy,
+ TSecretAccessPolicyConditions,
+ TSecretAccessPolicyConstraints,
+ TSecretAccessPolicyInputs,
+ TSecretAccessRequest,
+ TSecretAccessRequestData
+} from "./secret-access/secret-access-policy-types";
+
+export type TApprovalPolicy = TPamAccessPolicy | TCertRequestPolicy | TCodeSigningPolicy | TSecretAccessPolicy;
+export type TApprovalPolicyInputs =
+ | TPamAccessPolicyInputs
+ | TCertRequestPolicyInputs
+ | TCodeSigningPolicyInputs
+ | TSecretAccessPolicyInputs;
export type TApprovalPolicyConditions =
| TPamAccessPolicyConditions
| TCertRequestPolicyConditions
- | TCodeSigningPolicyConditions;
+ | TCodeSigningPolicyConditions
+ | TSecretAccessPolicyConditions;
export type TApprovalPolicyConstraints =
| TPamAccessPolicyConstraints
| TCertRequestPolicyConstraints
- | TCodeSigningPolicyConstraints;
-
-export type TApprovalRequest = TPamAccessRequest | TCertRequestRequest | TCodeSigningRequest;
-export type TApprovalRequestData = TPamAccessRequestData | TCertRequestRequestData | TCodeSigningRequestData;
+ | TCodeSigningPolicyConstraints
+ | TSecretAccessPolicyConstraints;
+
+export type TApprovalRequest = TPamAccessRequest | TCertRequestRequest | TCodeSigningRequest | TSecretAccessRequest;
+export type TApprovalRequestData =
+ | TPamAccessRequestData
+ | TCertRequestRequestData
+ | TCodeSigningRequestData
+ | TSecretAccessRequestData;
// Bypass-affordance fields the service stamps onto every request response.
export type TBypassAffordances = {
diff --git a/backend/src/services/approval-policy/secret-access/secret-access-policy-factory.ts b/backend/src/services/approval-policy/secret-access/secret-access-policy-factory.ts
new file mode 100644
index 0000000000..4b11222162
--- /dev/null
+++ b/backend/src/services/approval-policy/secret-access/secret-access-policy-factory.ts
@@ -0,0 +1,31 @@
+import { BadRequestError } from "@app/lib/errors";
+
+import { TApprovalResourceFactory } from "../approval-policy-types";
+import { TSecretAccessPolicy, TSecretAccessPolicyInputs, TSecretAccessRequestData } from "./secret-access-policy-types";
+
+const unsupported = () =>
+ new BadRequestError({
+ message: "Secret access approval requests are not supported on the global approval system yet"
+ });
+
+export const secretAccessPolicyFactory: TApprovalResourceFactory<
+ TSecretAccessPolicyInputs,
+ TSecretAccessPolicy,
+ TSecretAccessRequestData
+> = () => ({
+ matchPolicy: async () => {
+ throw unsupported();
+ },
+ canAccess: async () => {
+ throw unsupported();
+ },
+ validateConstraints: () => {
+ throw unsupported();
+ },
+ postApprovalRoutine: async () => {
+ throw unsupported();
+ },
+ postRejectionRoutine: async () => {
+ throw unsupported();
+ }
+});
diff --git a/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts b/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts
new file mode 100644
index 0000000000..fecee38855
--- /dev/null
+++ b/backend/src/services/approval-policy/secret-access/secret-access-policy-schemas.ts
@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+import { BaseApprovalPolicySchema, BaseApprovalRequestSchema } from "../approval-policy-schemas";
+
+export const SecretAccessPolicyInputsSchema = z.object({});
+
+export const SecretAccessPolicyConditionsSchema = z.object({});
+
+export const SecretAccessPolicyConstraintsSchema = z.object({
+ allowedSelfApprovals: z.boolean(),
+ requestExpirationTime: z.string().nullable()
+});
+
+export const SecretAccessPolicyRequestDataSchema = z.object({});
+
+export const SecretAccessPolicySchema = BaseApprovalPolicySchema.extend({
+ conditions: z.object({
+ version: z.literal(1),
+ conditions: SecretAccessPolicyConditionsSchema
+ }),
+ constraints: z.object({
+ version: z.literal(1),
+ constraints: SecretAccessPolicyConstraintsSchema
+ })
+});
+
+export const SecretAccessRequestSchema = BaseApprovalRequestSchema.extend({
+ requestData: z.object({
+ version: z.literal(1),
+ requestData: SecretAccessPolicyRequestDataSchema
+ })
+});
diff --git a/backend/src/services/approval-policy/secret-access/secret-access-policy-types.ts b/backend/src/services/approval-policy/secret-access/secret-access-policy-types.ts
new file mode 100644
index 0000000000..aaa9c80762
--- /dev/null
+++ b/backend/src/services/approval-policy/secret-access/secret-access-policy-types.ts
@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+import {
+ SecretAccessPolicyConditionsSchema,
+ SecretAccessPolicyConstraintsSchema,
+ SecretAccessPolicyInputsSchema,
+ SecretAccessPolicyRequestDataSchema,
+ SecretAccessPolicySchema,
+ SecretAccessRequestSchema
+} from "./secret-access-policy-schemas";
+
+export type TSecretAccessPolicy = z.infer<typeof SecretAccessPolicySchema>;
+export type TSecretAccessPolicyInputs = z.infer<typeof SecretAccessPolicyInputsSchema>;
+export type TSecretAccessPolicyConditions = z.infer<typeof SecretAccessPolicyConditionsSchema>;
+export type TSecretAccessPolicyConstraints = z.infer<typeof SecretAccessPolicyConstraintsSchema>;
+
+export type TSecretAccessRequest = z.infer<typeof SecretAccessRequestSchema>;
+export type TSecretAccessRequestData = z.infer<typeof SecretAccessPolicyRequestDataSchema>;
diff --git a/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts
new file mode 100644
index 0000000000..4a693dbd27
--- /dev/null
+++ b/backend/src/services/secret-access-approval-bridge/secret-access-approval-bridge-fns.ts
@@ -0,0 +1,24 @@
+import { TAccessApprovalPolicyDALFactory } from "@app/ee/services/access-approval-policy/access-approval-policy-dal";
+import { TApprovalPolicySecretEnvironmentDALFactory } from "@app/services/approval-policy/approval-policy-dal";
+
+type TSecretAccessApprovalPolicyExistsDep = {
+ accessApprovalPolicyDAL: Pick<TAccessApprovalPolicyDALFactory, "findPolicyByEnvIdAndSecretPath">;
+ approvalPolicySecretEnvironmentDAL: Pick<
+ TApprovalPolicySecretEnvironmentDALFactory,
+ "findPolicyByEnvIdsAndSecretPath"
+ >;
+};
+
+export const secretAccessApprovalPolicyExists = async (
+ { envId, secretPath }: { envId: string; secretPath: string },
+ { accessApprovalPolicyDAL, approvalPolicySecretEnvironmentDAL }: TSecretAccessApprovalPolicyExistsDep
+) => {
+ const legacyPolicy = await accessApprovalPolicyDAL.findPolicyByEnvIdAndSecretPath({ envIds: [envId], secretPath });
+ if (legacyPolicy) return true;
+
+ const policy = await approvalPolicySecretEnvironmentDAL.findPolicyByEnvIdsAndSecretPath({
+ envIds: [envId],
+ secretPath
+ });
+ return Boolean(policy);
+};
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 8311cfd46e..1b4fd72150 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
@@ -1,5 +1,284 @@
-export type TSecretGlobalAccessApprovalBridgeServiceFactory = ReturnType<
- typeof secretGlobalAccessApprovalBridgeServiceFactory
->;
+import { ForbiddenError } from "@casl/ability";
-export const secretGlobalAccessApprovalBridgeServiceFactory = () => ({});
+import { ActionProjectType } from "@app/db/schemas";
+import { approvalPolicyMembershipVerifierFactory } from "@app/ee/services/access-approval-policy/access-approval-policy-fns";
+import { ApproverType, BypasserType } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+import { ProjectPermissionActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
+import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { groupBy } from "@app/lib/fn";
+import { ApprovalPolicyType } from "@app/services/approval-policy/approval-policy-enums";
+
+import { secretAccessApprovalPolicyExists } from "./secret-access-approval-bridge-fns";
+import {
+ TCreateSecretAccessApprovalPolicyDTO,
+ TSecretAccessApprovalBridgeServiceFactoryDep
+} from "./secret-access-approval-bridge-types";
+
+export type TSecretAccessApprovalBridgeServiceFactory = ReturnType<typeof secretAccessApprovalBridgeServiceFactory>;
+
+export const secretAccessApprovalBridgeServiceFactory = ({
+ projectDAL,
+ permissionService,
+ projectEnvDAL,
+ userDAL,
+ accessApprovalPolicyDAL,
+ approvalPolicyDAL,
+ approvalPolicyStepsDAL,
+ approvalPolicyStepApproversDAL,
+ approvalPolicyBypassersDAL,
+ approvalPolicySecretEnvironmentDAL
+}: TSecretAccessApprovalBridgeServiceFactoryDep) => {
+ const { verifyProjectSubjectsMembership } = approvalPolicyMembershipVerifierFactory({ projectDAL });
+
+ const createAccessApprovalPolicy = async ({
+ name,
+ actor,
+ actorId,
+ actorOrgId,
+ secretPath,
+ actorAuthMethod,
+ approvals,
+ approvers,
+ bypassers,
+ projectSlug,
+ environment,
+ environments,
+ enforcementLevel,
+ allowedSelfApprovals,
+ approvalsRequired,
+ maxTimePeriod,
+ requestExpirationTime
+ }: TCreateSecretAccessApprovalPolicyDTO) => {
+ const project = await projectDAL.findProjectBySlug(projectSlug, actorOrgId);
+ if (!project) throw new NotFoundError({ message: `Project with slug '${projectSlug}' not found` });
+
+ const groupApprovers = approvers.filter((approver) => approver.type === ApproverType.Group) as {
+ id: string;
+ sequence?: number;
+ }[];
+
+ const userApprovers = approvers.filter((approver) => approver.type === ApproverType.User && approver.id) as {
+ id: string;
+ sequence?: number;
+ }[];
+
+ const userApproverNames = approvers.filter(
+ (approver) => approver.type === ApproverType.User && approver.username
+ ) as { username: string; sequence?: number }[];
+
+ const { permission } = await permissionService.getProjectPermission({
+ actor,
+ actorId,
+ projectId: project.id,
+ actorAuthMethod,
+ actorOrgId,
+ actionProjectType: ActionProjectType.SecretManager
+ });
+
+ ForbiddenError.from(permission).throwUnlessCan(
+ ProjectPermissionActions.Create,
+ ProjectPermissionSub.SecretApproval
+ );
+
+ const mergedEnvs = (environment ? [environment] : environments) || [];
+ if (mergedEnvs.length === 0) {
+ throw new BadRequestError({ message: "Must provide either environment or environments" });
+ }
+ const envs = await projectEnvDAL.find({ $in: { slug: mergedEnvs }, projectId: project.id });
+ if (!envs.length || envs.length !== mergedEnvs.length) {
+ const notFoundEnvs = mergedEnvs.filter((env) => !envs.find((el) => el.slug === env));
+ throw new NotFoundError({ message: `One or more environments not found: ${notFoundEnvs.join(", ")}` });
+ }
+
+ for (const env of envs) {
+ if (
+ // eslint-disable-next-line no-await-in-loop
+ await secretAccessApprovalPolicyExists(
+ { envId: env.id, secretPath },
+ { accessApprovalPolicyDAL, approvalPolicySecretEnvironmentDAL }
+ )
+ ) {
+ throw new BadRequestError({
+ message: `A policy for secret path '${secretPath}' already exists in environment '${env.slug}'`
+ });
+ }
+ }
+
+ let approverUserIds = userApprovers;
+ if (userApproverNames.length) {
+ const approverUsersInDB = await userDAL.find({
+ $in: {
+ username: userApproverNames.map((el) => el.username)
+ }
+ });
+ const approverUsersInDBGroupByUsername = groupBy(approverUsersInDB, (i) => i.username);
+ const invalidUsernames = userApproverNames.filter((el) => !approverUsersInDBGroupByUsername?.[el.username]?.[0]);
+
+ if (invalidUsernames.length) {
+ throw new BadRequestError({
+ message: `Invalid approver user: ${invalidUsernames.map((i) => i.username).join(", ")}`
+ });
+ }
+
+ approverUserIds = approverUserIds.concat(
+ userApproverNames.map((el) => ({
+ id: approverUsersInDBGroupByUsername[el.username]?.[0].id,
+ sequence: el.sequence
+ }))
+ );
+ }
+
+ if (approverUserIds.length > 0 || groupApprovers.length > 0) {
+ await verifyProjectSubjectsMembership({
+ userIds: approverUserIds.map((au) => au.id),
+ groupIds: groupApprovers.map((ga) => ga.id).filter(Boolean),
+ orgId: project.orgId,
+ projectId: project.id
+ });
+ }
+
+ let groupBypassers: string[] = [];
+ let bypasserUserIds: string[] = [];
+
+ if (bypassers && bypassers.length) {
+ groupBypassers = bypassers
+ .filter((bypasser) => bypasser.type === BypasserType.Group)
+ .map((bypasser) => bypasser.id) as string[];
+
+ const userBypassers = bypassers
+ .filter((bypasser) => bypasser.type === BypasserType.User)
+ .map((bypasser) => bypasser.id)
+ .filter(Boolean) as string[];
+
+ const userBypasserNames = bypassers
+ .map((bypasser) => (bypasser.type === BypasserType.User ? bypasser.username : undefined))
+ .filter(Boolean) as string[];
+
+ bypasserUserIds = userBypassers;
+ if (userBypasserNames.length) {
+ const bypasserUsers = await userDAL.find({
+ $in: {
+ username: userBypasserNames
+ }
+ });
+
+ const bypasserNamesFromDb = bypasserUsers.map((user) => user.username);
+ const invalidUsernames = userBypasserNames.filter((username) => !bypasserNamesFromDb.includes(username));
+
+ if (invalidUsernames.length) {
+ throw new BadRequestError({
+ message: `Invalid bypasser user: ${invalidUsernames.join(", ")}`
+ });
+ }
+
+ bypasserUserIds = bypasserUserIds.concat(bypasserUsers.map((user) => user.id));
+ }
+
+ if (bypasserUserIds.length) {
+ await verifyProjectSubjectsMembership({
+ userIds: bypasserUserIds,
+ groupIds: [],
+ orgId: project.orgId,
+ projectId: project.id
+ });
+ }
+ }
+
+ const approvalsRequiredGroupByStepNumber = groupBy(approvalsRequired || [], (i) => i.stepNumber);
+ const stepApproversBySequence = groupBy(
+ [
+ ...approverUserIds.map((el) => ({ type: ApproverType.User, id: el.id, sequence: el.sequence ?? 1 })),
+ ...groupApprovers.map((el) => ({ type: ApproverType.Group, id: el.id, sequence: el.sequence ?? 1 }))
+ ],
+ (el) => el.sequence
+ );
+ const steps = Object.keys(stepApproversBySequence)
+ .map(Number)
+ .sort((a, b) => a - b)
+ .map((sequence) => ({
+ sequence,
+ requiredApprovals: approvalsRequiredGroupByStepNumber?.[sequence]?.[0]?.numberOfApprovals ?? approvals,
+ approvers: stepApproversBySequence[sequence]
+ }));
+
+ const policy = await approvalPolicyDAL.transaction(async (tx) => {
+ const doc = await approvalPolicyDAL.create(
+ {
+ projectId: project.id,
+ organizationId: project.orgId,
+ type: ApprovalPolicyType.SecretAccess,
+ name,
+ enforcementLevel,
+ maxRequestTtl: maxTimePeriod ?? null,
+ bypassForMachineIdentities: false,
+ scopeType: null,
+ scopeId: null,
+ conditions: { version: 1, conditions: {} },
+ constraints: {
+ version: 1,
+ constraints: { allowedSelfApprovals, requestExpirationTime: requestExpirationTime ?? null }
+ }
+ },
+ tx
+ );
+
+ await approvalPolicySecretEnvironmentDAL.insertMany(
+ envs.map((env) => ({ policyId: doc.id, envId: env.id, secretPath })),
+ tx
+ );
+
+ const stepDocs = await approvalPolicyStepsDAL.insertMany(
+ steps.map((step, i) => ({
+ policyId: doc.id,
+ stepNumber: i + 1,
+ requiredApprovals: step.requiredApprovals
+ })),
+ tx
+ );
+
+ await approvalPolicyStepApproversDAL.insertMany(
+ steps.flatMap((step, i) =>
+ step.approvers.map((approver) => ({
+ policyStepId: stepDocs[i].id,
+ userId: approver.type === ApproverType.User ? approver.id : null,
+ groupId: approver.type === ApproverType.Group ? approver.id : null
+ }))
+ ),
+ tx
+ );
+
+ if (bypasserUserIds.length || groupBypassers.length) {
+ await approvalPolicyBypassersDAL.insertMany(
+ [
+ ...bypasserUserIds.map((userId) => ({ policyId: doc.id, userId, groupId: null })),
+ ...groupBypassers.map((groupId) => ({ policyId: doc.id, userId: null, groupId }))
+ ],
+ tx
+ );
+ }
+
+ return doc;
+ });
+
+ return {
+ id: policy.id,
+ name: policy.name,
+ secretPath,
+ approvals,
+ envId: envs[0].id,
+ createdAt: policy.createdAt,
+ updatedAt: policy.updatedAt,
+ enforcementLevel: policy.enforcementLevel,
+ deletedAt: null,
+ allowedSelfApprovals,
+ bypassForMachineIdentities: false,
+ maxTimePeriod: policy.maxRequestTtl ?? null,
+ requestExpirationTime: requestExpirationTime ?? null,
+ environment: envs[0],
+ environments: envs,
+ projectId: project.id
+ };
+ };
+
+ return { createAccessApprovalPolicy };
+};
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 cb0ff5c3b5..f145eb83a2 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
@@ -1 +1,31 @@
-export {};
+import { TAccessApprovalPolicyDALFactory } from "@app/ee/services/access-approval-policy/access-approval-policy-dal";
+import { TCreateAccessApprovalPolicy } from "@app/ee/services/access-approval-policy/access-approval-policy-types";
+import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
+import {
+ TApprovalPolicyBypassersDALFactory,
+ TApprovalPolicyDALFactory,
+ TApprovalPolicySecretEnvironmentDALFactory,
+ TApprovalPolicyStepApproversDALFactory,
+ TApprovalPolicyStepsDALFactory
+} from "@app/services/approval-policy/approval-policy-dal";
+import { TProjectDALFactory } from "@app/services/project/project-dal";
+import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
+import { TUserDALFactory } from "@app/services/user/user-dal";
+
+export type TSecretAccessApprovalBridgeServiceFactoryDep = {
+ projectDAL: Pick<TProjectDALFactory, "findProjectBySlug" | "findEffectiveProjectSubjectsMembership">;
+ permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
+ projectEnvDAL: Pick<TProjectEnvDALFactory, "find">;
+ userDAL: Pick<TUserDALFactory, "find">;
+ accessApprovalPolicyDAL: Pick<TAccessApprovalPolicyDALFactory, "findPolicyByEnvIdAndSecretPath">;
+ approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "create" | "transaction">;
+ approvalPolicyStepsDAL: Pick<TApprovalPolicyStepsDALFactory, "insertMany">;
+ approvalPolicyStepApproversDAL: Pick<TApprovalPolicyStepApproversDALFactory, "insertMany">;
+ approvalPolicyBypassersDAL: Pick<TApprovalPolicyBypassersDALFactory, "insertMany">;
+ approvalPolicySecretEnvironmentDAL: Pick<
+ TApprovalPolicySecretEnvironmentDALFactory,
+ "insertMany" | "findPolicyByEnvIdsAndSecretPath"
+ >;
+};
+
+export type TCreateSecretAccessApprovalPolicyDTO = TCreateAccessApprovalPolicy;