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 type { Expr as CELExpr } from "@/types/proto-es/google/api/expr/v1alpha1/syntax_pb";
import type {
CollectionExpr,
CollectionOperator,
CompareExpr,
CompareOperator,
ConditionGroupExpr,
EqualityExpr,
EqualityOperator,
ListFactor,
ListMembershipExpr,
ListMembershipOperator,
LogicalOperator,
Operator,
RawStringExpr,
SimpleExpr,
StringExpr,
StringFactor,
StringOperator,
} from "../types";
import {
ExprType,
isBooleanFactor,
isCollectionOperator,
isCompareOperator,
isConditionGroupExpr,
isEqualityOperator,
isListFactor,
isLogicalOperator,
isNegativeOperator,
isNumberFactor,
isStringFactor,
isStringOperator,
isTimestampFactor,
} from "../types";
import stringifyExpr from "./stringify";
// Helper functions to extract constant values from proto-es oneof patterns
const getConstantInt64Value = (expr: CELExpr): number => {
if (
expr.exprKind?.case === "constExpr" &&
expr.exprKind.value.constantKind?.case === "int64Value"
) {
return Number(expr.exprKind.value.constantKind.value);
}
return 0;
};
// The string a constant node carries; undefined for any other node.
export const constantStringOf = (
expr: CELExpr | undefined
): string | undefined =>
expr?.exprKind?.case === "constExpr" &&
expr.exprKind.value.constantKind?.case === "stringValue"
? expr.exprKind.value.constantKind.value
: undefined;
const getConstantStringValue = (expr: CELExpr): string =>
constantStringOf(expr) ?? "";
const getConstantBoolValue = (expr: CELExpr): boolean => {
if (
expr.exprKind?.case === "constExpr" &&
expr.exprKind.value.constantKind?.case === "boolValue"
) {
return expr.exprKind.value.constantKind.value;
}
return false;
};
// For simplify UI implementation, the "root" condition need to be a group.
export const wrapAsGroup = (
expr: SimpleExpr,
operator: LogicalOperator = "_&&_"
): ConditionGroupExpr => {
if (isConditionGroupExpr(expr)) return expr;
return {
type: ExprType.ConditionGroup,
operator,
args: [expr],
};
};
// Convert common expr to simple expr
export const resolveCELExpr = (expr: CELExpr): SimpleExpr => {
const dfs = (expr: CELExpr, negative: boolean = false): SimpleExpr => {
if (expr.exprKind?.case !== "callExpr") {
// If no callExpr, we treat it as a raw string.
return resolveRawStringExpr(expr);
}
const callExpr = expr.exprKind.value;
try {
const { args } = callExpr;
const operator = callExpr.function as Operator;
if (isLogicalOperator(operator)) {
const group: ConditionGroupExpr = {
type: ExprType.ConditionGroup,
operator,
args: [],
};
const [left, right] = args;
const sub = (subTree: CELExpr, expand: boolean) => {
const subExpr = dfs(subTree);
if (
expand &&
isConditionGroupExpr(subExpr) &&
subExpr.operator === operator
) {
group.args.push(...subExpr.args);
} else {
group.args.push(subExpr);
}
};
sub(left, true);
sub(right, false);
return group;
}
if (isNegativeOperator(operator)) {
return dfs(args[0], true);
}
if (isEqualityOperator(operator)) {
return resolveEqualityExpr(expr);
}
if (isCompareOperator(operator)) {
return resolveCompareExpr(expr);
}
if (isStringOperator(operator)) {
return resolveStringExpr(expr, negative);
}
if (isCollectionOperator(operator)) {
if (isListMembershipCall(expr)) {
return resolveListMembershipExpr(expr, negative);
}
return resolveCollectionExpr(expr, negative);
}
throw new Error(`unsupported expr "${JSON.stringify(expr)}"`);
} catch {
// Any error occurs, we treat it as a raw string.
return resolveRawStringExpr(expr);
}
};
return dfs(expr);
};
const isStringConstantExpr = (expr: CELExpr): boolean => {
return (
expr.exprKind?.case === "constExpr" &&
expr.exprKind.value.constantKind?.case === "stringValue"
);
};
const isListMembershipCall = (expr: CELExpr): boolean => {
const callExpr =
expr.exprKind?.case === "callExpr" ? expr.exprKind.value : null;
if (!callExpr || callExpr.function !== "@in") {
return false;
}
const [valueExpr, factorExpr] = callExpr.args;
if (!valueExpr || !factorExpr || !isStringConstantExpr(valueExpr)) {
return false;
}
try {
return isListFactor(getFactorName(factorExpr));
} catch {
return false;
}
};
const resolveEqualityExpr = (expr: CELExpr): EqualityExpr => {
const callExpr =
expr.exprKind?.case === "callExpr" ? expr.exprKind.value : null;
if (!callExpr)
throw new Error(`Expected callExpr but got ${expr.exprKind?.case}`);
const operator = callExpr.function as EqualityOperator;
const [factorExpr, valueExpr] = callExpr.args;
const factor = getFactorName(factorExpr);
if (isNumberFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [factor, getConstantInt64Value(valueExpr)],
};
}
if (isBooleanFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [factor, getConstantBoolValue(valueExpr)],
};
}
if (isStringFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [factor, getConstantStringValue(valueExpr)],
};
}
throw new Error(`cannot resolve expr ${JSON.stringify(expr)}`);
};
const resolveCompareExpr = (expr: CELExpr): CompareExpr => {
const callExpr =
expr.exprKind?.case === "callExpr" ? expr.exprKind.value : null;
if (!callExpr)
throw new Error(`Expected callExpr but got ${expr.exprKind?.case}`);
const operator = callExpr.function as CompareOperator;
const [factorExpr, valueExpr] = callExpr.args;
const factor = getFactorName(factorExpr);
if (isNumberFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [factor, getConstantInt64Value(valueExpr)],
};
}
if (isTimestampFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [
factor,
valueExpr.exprKind?.case === "callExpr" &&
valueExpr.exprKind.value.args[0]?.exprKind?.case === "constExpr"
? new Date(getConstantStringValue(valueExpr.exprKind.value.args[0]))
: new Date(),
],
};
}
throw new Error(`cannot resolve expr ${JSON.stringify(expr)}`);
};
const resolveStringExpr = (
expr: CELExpr,
negative: boolean = false
): StringExpr => {
const callExpr =
expr.exprKind?.case === "callExpr" ? expr.exprKind.value : null;
if (!callExpr)
throw new Error(`Expected callExpr but got ${expr.exprKind?.case}`);
let operator = callExpr.function as StringOperator;
if (negative && operator === "contains") {
operator = "@not_contains";
}
const factor = getFactorName(callExpr.target!);
const value = callExpr.args[0];
return {
type: ExprType.Condition,
operator,
args: [factor as StringFactor, getConstantStringValue(value)],
};
};
const resolveListMembershipExpr = (
expr: CELExpr,
negative: boolean = false
): ListMembershipExpr => {
const callExpr =
expr.exprKind?.case === "callExpr" ? expr.exprKind.value : null;
if (!callExpr)
throw new Error(`Expected callExpr but got ${expr.exprKind?.case}`);
const [valueExpr, factorExpr] = callExpr.args;
const operator: ListMembershipOperator = negative
? "@not_contains"
: "@contains";
return {
type: ExprType.Condition,
operator,
args: [
getFactorName(factorExpr) as ListFactor,
getConstantStringValue(valueExpr),
],
};
};
const resolveCollectionExpr = (
expr: CELExpr,
negative: boolean = false
): CollectionExpr => {
const callExpr =
expr.exprKind?.case === "callExpr" ? expr.exprKind.value : null;
if (!callExpr)
throw new Error(`Expected callExpr but got ${expr.exprKind?.case}`);
let operator = callExpr.function as CollectionOperator;
if (negative && operator === "@in") {
operator = "@not_in";
}
const [factorExpr, valuesExpr] = callExpr.args;
const factor = getFactorName(factorExpr);
if (isNumberFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [
factor,
valuesExpr.exprKind?.case === "listExpr"
? (valuesExpr.exprKind.value.elements?.map(getConstantInt64Value) ??
[])
: [],
],
};
}
if (isStringFactor(factor)) {
return {
type: ExprType.Condition,
operator,
args: [
factor,
valuesExpr.exprKind?.case === "listExpr"
? (valuesExpr.exprKind.value.elements?.map(getConstantStringValue) ??
[])
: [],
],
};
}
throw new Error(`cannot resolve expr ${JSON.stringify(expr)}`);
};
const resolveRawStringExpr = (expr: CELExpr): RawStringExpr => {
return {
type: ExprType.RawString,
content: stringifyExpr(expr),
};
};
export const emptySimpleExpr = (
operator: LogicalOperator = "_&&_"
): ConditionGroupExpr => {
return {
type: ExprType.ConditionGroup,
operator: operator,
args: [],
};
};
// `resource.environment_id` parses as a select on the ident `resource`; the
// dotted ident is what `buildCELExpr` emits. Only an ident or a select names a
// factor.
export const factorNameOf = (expr: CELExpr | undefined): string | undefined => {
if (expr?.exprKind?.case === "identExpr") {
return expr.exprKind.value.name;
}
if (expr?.exprKind?.case === "selectExpr") {
const { operand, field } = expr.exprKind.value;
const operandName =
operand?.exprKind?.case === "identExpr"
? operand.exprKind.value.name
: "";
return `${operandName}.${field}`;
}
return undefined;
};
const getFactorName = (expr: CELExpr): string => {
const name = factorNameOf(expr);
if (name === undefined) {
throw new Error(`cannot resolve factor name ${JSON.stringify(expr)}`);
}
return name;
};