Skip to content

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

5.1 KB
Raw Blame
import { create as createProto } from "@bufbuild/protobuf";
import { createContextValues } from "@connectrpc/connect";
import dayjs from "dayjs";
import { uniq } from "lodash-es";
import {
  issueServiceClientConnect,
  planServiceClientConnect,
  rolloutServiceClientConnect,
} from "@/api";
import { silentContextKey } from "@/api/context-key";
import type { IssueFilter } from "@/types";
import {
  ApprovalStatus,
  IssueStatus,
  RiskLevel,
} from "@/types/proto-es/v1/common_pb";
import {
  CreateIssueRequestSchema,
  GetIssueRequestSchema,
  type Issue,
  Issue_Type,
  SearchIssuesRequestSchema,
} from "@/types/proto-es/v1/issue_service_pb";
import {
  CreatePlanRequestSchema,
  type Plan,
} from "@/types/proto-es/v1/plan_service_pb";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
import { CreateRolloutRequestSchema } from "@/types/proto-es/v1/rollout_service_pb";
import { celString, celStringList } from "@/utils/v1/celLiteral";
import type { AppSliceCreator, IssueSlice } from "./types";

// Resource names are `projects/{project}/issues/{issue}` — yank the project
// resource out of the head.
function projectResourceFromIssueName(issueName: string): string {
  const match = issueName.match(/^(projects\/[^/]+)\//);
  return match?.[1] ?? "";
}

export const buildIssueFilter = (find: IssueFilter): string => {
  const filter: string[] = [];
  if (find.creator) {
    filter.push(`creator == ${celString(find.creator)}`);
  }
  if (find.currentApprover) {
    filter.push(`current_approver == ${celString(find.currentApprover)}`);
  }
  if (find.approvalStatus) {
    filter.push(
      `approval_status == ${celString(ApprovalStatus[find.approvalStatus])}`
    );
  }
  if (find.statusList && find.statusList.length > 0) {
    filter.push(
      `status in ${celStringList(find.statusList.map((s) => IssueStatus[s]))}`
    );
  }
  if (find.riskLevelList && find.riskLevelList.length > 0) {
    filter.push(
      `risk_level in ${celStringList(find.riskLevelList.map((r) => RiskLevel[r]))}`
    );
  }
  if (find.createdTsAfter) {
    filter.push(
      `create_time >= ${celString(dayjs(find.createdTsAfter).utc().format())}`
    );
  }
  if (find.createdTsBefore) {
    filter.push(
      `create_time <= ${celString(dayjs(find.createdTsBefore).utc().format())}`
    );
  }
  if (find.typeList && find.typeList.length > 0) {
    filter.push(
      `type in ${celStringList(find.typeList.map((t) => Issue_Type[t]))}`
    );
  }
  if (find.labels && find.labels.length > 0) {
    filter.push(`labels in ${celStringList(find.labels)}`);
  }
  return filter.join(" && ");
};

export interface CreateIssueByPlanOptions {
  skipRollout?: boolean;
}

/**
 * Creates a plan, then an issue referencing it, and (unless skipped) a rollout.
 * A stateless orchestration helper over the plan/issue/rollout services.
 */
export const experimentalCreateIssueByPlan = async (
  project: Project,
  issueCreate: Issue,
  planCreate: Plan,
  options?: CreateIssueByPlanOptions
) => {
  const createdPlan = await planServiceClientConnect.createPlan(
    createProto(CreatePlanRequestSchema, {
      parent: project.name,
      plan: planCreate,
    })
  );
  issueCreate.plan = createdPlan.name;

  const createdIssue = await issueServiceClientConnect.createIssue(
    createProto(CreateIssueRequestSchema, {
      parent: project.name,
      issue: issueCreate,
    })
  );

  // Skip rollout creation for plans that create rollout on-demand
  // (e.g., database creation).
  if (options?.skipRollout) {
    return { createdPlan, createdIssue, createdRollout: undefined };
  }

  const createdRollout = await rolloutServiceClientConnect.createRollout(
    createProto(CreateRolloutRequestSchema, {
      parent: createdPlan.name,
    })
  );

  return { createdPlan, createdIssue, createdRollout };
};

/**
 * Stateless fetches (no per-issue cache — callers consume the result once)
 * that also prime the owning project(s) in the app store so downstream code
 * that reads a project synchronously after the call sees it cached.
 */
export const createIssueSlice: AppSliceCreator<IssueSlice> = (_set, get) => ({
  fetchIssueByName: async (name, silent = false) => {
    const issue = await issueServiceClientConnect.getIssue(
      createProto(GetIssueRequestSchema, { name }),
      {
        contextValues: createContextValues().set(silentContextKey, silent),
      }
    );
    const projectName = projectResourceFromIssueName(issue.name);
    if (projectName) {
      await get().fetchProject(projectName);
    }
    return issue;
  },

  listIssues: async ({ find, pageSize, pageToken }) => {
    const resp = await issueServiceClientConnect.searchIssues(
      createProto(SearchIssuesRequestSchema, {
        parent: find.project,
        filter: buildIssueFilter(find),
        query: find.query,
        pageSize,
        pageToken,
        orderBy: find.orderBy,
      })
    );
    const issues = resp.issues;
    await get().batchFetchProjects(
      uniq(
        issues.map((issue) => projectResourceFromIssueName(issue.name))
      ).filter(Boolean)
    );
    await get().batchGetOrFetchUsers(
      uniq(issues.map((issue) => issue.creator))
    );
    return { nextPageToken: resp.nextPageToken, issues };
  },
});