Skip to content

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

8.8 KB
Raw Blame
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
  };
};