Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

12.0 KB
Raw Blame
import { create } from "@bufbuild/protobuf";
import { createContextValues } from "@connectrpc/connect";
import { issueServiceClientConnect } from "@/api";
import { silentContextKey } from "@/api/context-key";
import {
  getProjectSetupSteps,
  type ProjectSetupState,
  type ProjectSetupStep,
  type ResourceAvailability,
} from "@/lib/projectSetup";
import { useAppStore } from "@/stores/app";
import { buildIssueFilter } from "@/stores/app/issue";
import type { Permission } from "@/types/iam";
import { IssueStatus, State } from "@/types/proto-es/v1/common_pb";
import {
  Issue_Type,
  SearchIssuesRequestSchema,
} from "@/types/proto-es/v1/issue_service_pb";
import { ProjectSchema } from "@/types/proto-es/v1/project_service_pb";
import type { AgentEvidence, AgentEvidenceReference } from "../types";
import { createProjectOpenIssuesTool } from "./projectOpenIssues";

const DATABASE_PAGE_SIZE = 3;
const DATABASE_CHANGE_PAGE_SIZE = 5;

type EvidenceFacet<Key extends string, Value> =
  | ({
      status: "available";
      partial: boolean;
    } & Record<Key, Value>)
  | {
      status: "unavailable";
    };

type ProjectIssue = {
  name: string;
  title: string;
  relation: "review" | "created";
  approvalStatus: string;
};

type DatabaseChange = {
  name: string;
  title: string;
};

export type ProjectOverview = {
  project: string;
  personalIssues: EvidenceFacet<"issues", ProjectIssue[]>;
  databases: EvidenceFacet<"databases", { name: string }[]>;
  openDatabaseChanges: EvidenceFacet<"issues", DatabaseChange[]>;
  setup?: ProjectSetupState & { recommendedStep?: ProjectSetupStep };
  evidence: AgentEvidence;
};

async function collectProjectSetup(
  projectName: string
): Promise<ProjectSetupState> {
  const initialState = useAppStore.getState();
  if (
    !initialState.currentUser ||
    !initialState.workspacePolicy ||
    !initialState.roles.length
  ) {
    await initialState.loadWorkspacePermissionState().catch(() => undefined);
  }
  if (!useAppStore.getState().projectPoliciesByName[projectName]) {
    await useAppStore
      .getState()
      .loadProjectIamPolicy(projectName, true)
      .catch(() => undefined);
  }
  const state = useAppStore.getState();
  const project = create(ProjectSchema, { name: projectName });
  const workspacePermissionKnown = Boolean(
    state.currentUser && state.workspacePolicy && state.roles.length
  );
  const projectPermissionKnown = Boolean(
    workspacePermissionKnown && state.projectPoliciesByName[projectName]
  );
  const workspaceAllows = (permission: Permission) =>
    !workspacePermissionKnown || state.hasWorkspacePermission(permission);
  const projectAllows = (permission: Permission) =>
    !projectPermissionKnown || state.hasProjectPermission(project, permission);
  const defaultProject = state.serverInfo?.defaultProject ?? "";
  const workspaceName = state.workspaceResourceName();
  const canListProjectInstances =
    projectName !== defaultProject && projectAllows("bb.instances.list");
  const canListWorkspaceInstances = workspaceAllows("bb.instances.list");
  const canTransferDatabases =
    workspaceAllows("bb.databases.list") &&
    workspaceAllows("bb.databases.update") &&
    projectAllows("bb.databases.update") &&
    Boolean(defaultProject && workspaceName);

  if (!defaultProject) {
    return {
      isDefault: false,
      instance: "unknown",
      transferableDatabase: "unknown",
      canConnectInstance: false,
      canTransferDatabases: false,
      canCreateDatabase: false,
    };
  }

  if (projectName === defaultProject) {
    return {
      isDefault: true,
      instance: "unknown",
      transferableDatabase: "unknown",
      canConnectInstance: false,
      canTransferDatabases: false,
      canCreateDatabase: false,
    };
  }

  const instanceRequests = [
    ...(canListProjectInstances ? [projectName] : []),
    ...(canListWorkspaceInstances ? [undefined] : []),
  ].map(async (parent) => {
    const { instances } = await state.fetchInstanceList({
      parent,
      pageSize: 1,
      filter: { state: State.ACTIVE },
      silent: true,
    });
    return instances.length ? ("present" as const) : ("empty" as const);
  });
  const [instanceResults, transferableDatabase] = await Promise.all([
    Promise.allSettled(instanceRequests),
    canTransferDatabases
      ? state
          .fetchDatabases({
            parent: workspaceName,
            pageSize: 1,
            filter: { project: defaultProject },
            silent: true,
          })
          .then(({ databases }) =>
            databases.length ? ("present" as const) : ("empty" as const)
          )
          .catch(() => "unknown" as const)
      : Promise.resolve("empty" as const),
  ]);
  const instanceStates = instanceResults.map((result) =>
    result.status === "fulfilled" ? result.value : "unknown"
  );
  const instance: ResourceAvailability = instanceStates.includes("present")
    ? "present"
    : !instanceStates.length || instanceStates.includes("unknown")
      ? "unknown"
      : "empty";
  return {
    isDefault: false,
    instance,
    transferableDatabase,
    canConnectInstance:
      projectName !== defaultProject && projectAllows("bb.instances.create"),
    canTransferDatabases,
    canCreateDatabase:
      projectAllows("bb.databases.list") &&
      projectAllows("bb.instances.list") &&
      projectAllows("bb.issues.create") &&
      projectAllows("bb.plans.create") &&
      projectAllows("bb.sheets.create"),
  };
}

function isProjectName(value: string | undefined): value is string {
  return !!value && /^projects\/[^/]+$/.test(value);
}

function unavailableFacet<Key extends string, Value>(): EvidenceFacet<
  Key,
  Value
> {
  return { status: "unavailable" };
}

function collectEvidenceReferences(
  project: string,
  personalIssues: EvidenceFacet<"issues", ProjectIssue[]>,
  databases: EvidenceFacet<"databases", { name: string }[]>,
  openDatabaseChanges: EvidenceFacet<"issues", DatabaseChange[]>
): AgentEvidence {
  const references: AgentEvidenceReference[] = [];
  const seen = new Set<string>();
  const add = (reference: AgentEvidenceReference) => {
    const key = `${reference.kind}:${reference.name}`;
    if (seen.has(key)) return;
    seen.add(key);
    references.push(reference);
  };

  if (openDatabaseChanges.status === "available") {
    for (const issue of openDatabaseChanges.issues) {
      add({ kind: "issue", name: issue.name, title: issue.title });
    }
  }
  if (personalIssues.status === "available") {
    for (const issue of personalIssues.issues) {
      add({ kind: "issue", name: issue.name, title: issue.title });
    }
  }
  if (databases.status === "available") {
    for (const database of databases.databases) {
      add({ kind: "database", name: database.name });
    }
  }

  return { project, references };
}

function parsePersonalIssues(
  value: string
): EvidenceFacet<"issues", ProjectIssue[]> {
  try {
    const payload = JSON.parse(value) as Record<string, unknown>;
    if (typeof payload.error === "string" || !Array.isArray(payload.issues)) {
      return unavailableFacet();
    }
    const issues = payload.issues.flatMap((issue) => {
      if (!issue || typeof issue !== "object") return [];
      const candidate = issue as Record<string, unknown>;
      if (
        typeof candidate.name !== "string" ||
        typeof candidate.title !== "string" ||
        (candidate.relation !== "review" && candidate.relation !== "created") ||
        typeof candidate.approvalStatus !== "string"
      ) {
        return [];
      }
      const relation: ProjectIssue["relation"] =
        candidate.relation === "review" ? "review" : "created";
      return [
        {
          name: candidate.name,
          title: candidate.title,
          relation,
          approvalStatus: candidate.approvalStatus,
        },
      ];
    });
    return {
      status: "available",
      partial: payload.partial === true,
      issues,
    };
  } catch {
    return unavailableFacet();
  }
}

export async function collectProjectOverview(
  projectName: string | undefined
): Promise<ProjectOverview | null> {
  if (!isProjectName(projectName)) {
    return null;
  }

  const { fetchDatabases } = useAppStore.getState();
  const results = await Promise.allSettled([
    createProjectOpenIssuesTool({ projectName })(),
    fetchDatabases({
      parent: projectName,
      pageSize: DATABASE_PAGE_SIZE,
      silent: true,
    }),
    issueServiceClientConnect.searchIssues(
      create(SearchIssuesRequestSchema, {
        parent: projectName,
        filter: buildIssueFilter({
          project: projectName,
          query: "",
          typeList: [Issue_Type.DATABASE_CHANGE],
          statusList: [IssueStatus.OPEN],
        }),
        orderBy: "update_time desc",
        pageSize: DATABASE_CHANGE_PAGE_SIZE,
      }),
      { contextValues: createContextValues().set(silentContextKey, true) }
    ),
  ]);

  const personalIssues =
    results[0].status === "fulfilled"
      ? parsePersonalIssues(results[0].value)
      : unavailableFacet<"issues", ProjectIssue[]>();
  const databases =
    results[1].status === "fulfilled"
      ? {
          status: "available" as const,
          partial: Boolean(results[1].value.nextPageToken),
          databases: results[1].value.databases.map((database) => ({
            name: database.name,
          })),
        }
      : unavailableFacet<"databases", { name: string }[]>();
  const openDatabaseChanges =
    results[2].status === "fulfilled"
      ? {
          status: "available" as const,
          partial: Boolean(results[2].value.nextPageToken),
          issues: results[2].value.issues.map((issue) => ({
            name: issue.name,
            title: issue.title,
          })),
        }
      : unavailableFacet<"issues", DatabaseChange[]>();
  const setupState =
    databases.status === "available" &&
    useAppStore.getState().projectsByName[projectName]?.state !== State.DELETED
      ? await collectProjectSetup(projectName)
      : undefined;
  const recommendedStep =
    setupState &&
    databases.status === "available" &&
    !databases.partial &&
    databases.databases.length === 0
      ? getProjectSetupSteps(setupState)[0]
      : undefined;

  return {
    project: projectName,
    personalIssues,
    databases,
    openDatabaseChanges,
    ...(setupState
      ? {
          setup: {
            ...setupState,
            ...(recommendedStep ? { recommendedStep } : {}),
          },
        }
      : {}),
    evidence: collectEvidenceReferences(
      projectName,
      personalIssues,
      databases,
      openDatabaseChanges
    ),
  };
}

export function extractProjectOverviewEvidence(
  result: string
): AgentEvidence | undefined {
  try {
    const payload = JSON.parse(result) as { evidence?: unknown };
    const evidence = payload.evidence;
    if (!evidence || typeof evidence !== "object") return undefined;

    const candidate = evidence as {
      project?: unknown;
      references?: unknown;
    };
    const project = candidate.project;
    const rawReferences = candidate.references;
    if (
      typeof project !== "string" ||
      !isProjectName(project) ||
      !Array.isArray(rawReferences)
    ) {
      return undefined;
    }

    const references: AgentEvidenceReference[] = [];
    for (const reference of rawReferences) {
      if (!reference || typeof reference !== "object") continue;
      const value = reference as Record<string, unknown>;
      if (
        value.kind === "issue" &&
        typeof value.name === "string" &&
        typeof value.title === "string"
      ) {
        references.push({
          kind: "issue",
          name: value.name,
          title: value.title,
        });
        continue;
      }
      if (value.kind === "database" && typeof value.name === "string") {
        references.push({ kind: "database", name: value.name });
      }
    }

    return { project, references };
  } catch {
    return undefined;
  }
}

export function createProjectOverviewTool({
  projectName,
}: {
  projectName?: string;
}) {
  return async (): Promise<string> => {
    const overview = await collectProjectOverview(projectName);
    return JSON.stringify(
      overview ?? { error: "This chat is not bound to a project." }
    );
  };
}