Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
import { Knex } from "knex";
import { TDbClient } from "@app/db";
import { TableName, TAdditionalPrivileges } from "@app/db/schemas";
import { DatabaseError } from "@app/lib/errors";
import { chunkArray } from "@app/lib/fn";
import { buildFindFilter, ormify, selectAllTableCols, TFindFilter } from "@app/lib/knex";
import { ApprovalRequestGrantStatus } from "@app/services/approval-policy/approval-policy-enums";
import { ActorType } from "@app/services/auth/auth-type";
export type TAdditionalPrivilegeDALFactory = ReturnType<typeof additionalPrivilegeDALFactory>;
const groupApproverUserIdsByPolicyId = (
rows: { policyId: string; approverUserId?: string | null; groupMemberUserId?: string | null }[]
) =>
rows.reduce<Record<string, string[]>>((acc, row) => {
const uid = String(row.approverUserId || row.groupMemberUserId || "");
if (uid) {
const pid = String(row.policyId);
if (!acc[pid]) acc[pid] = [];
if (!acc[pid].includes(uid)) acc[pid].push(uid);
}
return acc;
}, {});
export const additionalPrivilegeDALFactory = (db: TDbClient) => {
const orm = ormify(db, TableName.AdditionalPrivilege);
const findWithAccessApprovalStatus = async (filter: TFindFilter<TAdditionalPrivileges>) => {
const docs = await db
.replicaNode()(TableName.AdditionalPrivilege)
// eslint-disable-next-line @typescript-eslint/no-misused-promises
.where(buildFindFilter(filter, TableName.AdditionalPrivilege))
.leftJoin(
TableName.AccessApprovalRequest,
`${TableName.AdditionalPrivilege}.id`,
`${TableName.AccessApprovalRequest}.privilegeId`
)
.leftJoin(
TableName.ApprovalRequestGrants,
`${TableName.AdditionalPrivilege}.grantId`,
`${TableName.ApprovalRequestGrants}.id`
)
.leftJoin(
TableName.ApprovalRequests,
`${TableName.ApprovalRequestGrants}.requestId`,
`${TableName.ApprovalRequests}.id`
)
.select(selectAllTableCols(TableName.AdditionalPrivilege))
.select(
db.ref("id").withSchema(TableName.AccessApprovalRequest).as("accessApprovalRequestId"),
db.ref("policyId").withSchema(TableName.AccessApprovalRequest).as("accessApprovalPolicyId"),
db.ref("id").withSchema(TableName.ApprovalRequests).as("approvalRequestId"),
db.ref("policyId").withSchema(TableName.ApprovalRequests).as("approvalPolicyId")
);
const legacyPolicyIds = [
...new Set(
docs
.filter((doc) => !doc.grantId && doc.accessApprovalPolicyId)
.map((doc) => String(doc.accessApprovalPolicyId))
)
];
const globalPolicyIds = [
...new Set(docs.filter((doc) => doc.grantId && doc.approvalPolicyId).map((doc) => String(doc.approvalPolicyId)))
];
let legacyApproversByPolicyId: Record<string, string[]> = {};
if (legacyPolicyIds.length > 0) {
const approverRows = await db
.replicaNode()(TableName.AccessApprovalPolicyApprover)
.whereIn(`${TableName.AccessApprovalPolicyApprover}.policyId`, legacyPolicyIds)
.leftJoin(
TableName.UserGroupMembership,
`${TableName.AccessApprovalPolicyApprover}.approverGroupId`,
`${TableName.UserGroupMembership}.groupId`
)
.select(
db.ref("policyId").withSchema(TableName.AccessApprovalPolicyApprover),
db.ref("approverUserId").withSchema(TableName.AccessApprovalPolicyApprover),
db.ref("userId").withSchema(TableName.UserGroupMembership).as("groupMemberUserId")
);
legacyApproversByPolicyId = groupApproverUserIdsByPolicyId(approverRows);
}
let globalApproversByPolicyId: Record<string, string[]> = {};
if (globalPolicyIds.length > 0) {
const approverRows = await db
.replicaNode()(TableName.ApprovalPolicySteps)
.whereIn(`${TableName.ApprovalPolicySteps}.policyId`, globalPolicyIds)
.join(
TableName.ApprovalPolicyStepApprovers,
`${TableName.ApprovalPolicySteps}.id`,
`${TableName.ApprovalPolicyStepApprovers}.policyStepId`
)
.leftJoin(
TableName.UserGroupMembership,
`${TableName.ApprovalPolicyStepApprovers}.groupId`,
`${TableName.UserGroupMembership}.groupId`
)
.select(
db.ref("policyId").withSchema(TableName.ApprovalPolicySteps),
db.ref("userId").withSchema(TableName.ApprovalPolicyStepApprovers).as("approverUserId"),
db.ref("userId").withSchema(TableName.UserGroupMembership).as("groupMemberUserId")
);
globalApproversByPolicyId = groupApproverUserIdsByPolicyId(approverRows);
}
return docs.map(({ approvalRequestId, approvalPolicyId, ...doc }) => {
if (doc.grantId) {
return {
...doc,
isLinkedToAccessApproval: Boolean(approvalRequestId),
accessApprovalRequestId: (approvalRequestId ?? null) as string | null,
policyApproverUserIds: approvalPolicyId ? (globalApproversByPolicyId[String(approvalPolicyId)] ?? []) : []
};
}
const pid = doc.accessApprovalPolicyId ? String(doc.accessApprovalPolicyId) : null;
return {
...doc,
isLinkedToAccessApproval: Boolean(doc.accessApprovalRequestId),
accessApprovalRequestId: (doc.accessApprovalRequestId ?? null) as string | null,
policyApproverUserIds: pid ? (legacyApproversByPolicyId[pid] ?? []) : []
};
});
};
const isLinkedToAccessApproval = async (privilegeId: string): Promise<boolean> => {
const result = await db.replicaNode()(TableName.AccessApprovalRequest).where({ privilegeId }).first();
return Boolean(result);
};
// Without an actor, returns the folder grants of every user and identity in the project.
const findFolderScopedPrivileges = async (
{
projectId,
actorId,
actorType
}: { projectId: string; actorId?: string; actorType?: ActorType.USER | ActorType.IDENTITY },
tx?: Knex
) => {
const docs = await (tx || db)(TableName.AdditionalPrivilege)
.where({ projectId })
.whereNotNull("folderId")
.where((qb) => {
if (actorId) {
void qb.where(actorType === ActorType.IDENTITY ? { actorIdentityId: actorId } : { actorUserId: actorId });
}
})
.select(
"id",
"name",
"folderId",
"role",
"isTemporary",
"temporaryAccessEndTime",
"actorUserId",
"actorIdentityId"
);
return docs as {
id: string;
name: string;
folderId: string;
role: string | null;
isTemporary: boolean;
temporaryAccessEndTime: Date | null;
actorUserId: string | null;
actorIdentityId: string | null;
}[];
};
const remapFolderIds = async (pairs: { oldFolderId: string; newFolderId: string }[], tx: Knex) => {
for (const chunk of chunkArray(pairs, 500)) {
const values = chunk.map(() => "(?::uuid, ?::uuid)").join(", ");
const bindings = chunk.flatMap(({ oldFolderId, newFolderId }) => [oldFolderId, newFolderId]);
// eslint-disable-next-line no-await-in-loop
await tx.raw(
`UPDATE ${TableName.AdditionalPrivilege} AS ap
SET "folderId" = m.new_id
FROM (VALUES ${values}) AS m(old_id, new_id)
WHERE ap."folderId" = m.old_id`,
bindings
);
}
};
const $revokeGrantsOfDeletedPrivileges = async (privileges: TAdditionalPrivileges[], tx: Knex) => {
const grantIds = privileges.map(({ grantId }) => grantId).filter((grantId): grantId is string => Boolean(grantId));
if (!grantIds.length) return;
try {
for (const chunk of chunkArray(grantIds, 500)) {
// eslint-disable-next-line no-await-in-loop
await tx(TableName.ApprovalRequestGrants)
.whereIn("id", chunk)
.where("status", ApprovalRequestGrantStatus.Active)
.update({ status: ApprovalRequestGrantStatus.Revoked, revokedAt: new Date() });
}
} catch (error) {
throw new DatabaseError({ error, name: "Revoke grants of deleted additional privileges" });
}
};
// The grantId FK only nulls itself on delete, so the grant would otherwise stay active with no privilege behind it.
const deleteById: typeof orm.deleteById = async (id, tx) => {
const run = async (trx: Knex) => {
const doc = await orm.deleteById(id, trx);
if (doc) await $revokeGrantsOfDeletedPrivileges([doc], trx);
return doc;
};
return tx ? run(tx) : orm.transaction(run);
};
const deleteFn: typeof orm.delete = async (filter, tx) => {
const run = async (trx: Knex) => {
const docs = await orm.delete(filter, trx);
await $revokeGrantsOfDeletedPrivileges(docs, trx);
return docs;
};
return tx ? run(tx) : orm.transaction(run);
};
return {
...orm,
deleteById,
delete: deleteFn,
findWithAccessApprovalStatus,
isLinkedToAccessApproval,
findFolderScopedPrivileges,
remapFolderIds
};
};