Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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 };
},
});