Skip to content

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

6.5 KB
Raw Blame
import { flatten, isUndefined } from "lodash-es";
import { useAppStore } from "@/stores/app";
import {
  databaseNamePrefix,
  instanceNamePrefix,
} from "@/stores/modules/v1/common";
import type { DatabaseResource } from "@/types";
import { Engine } from "@/types/proto-es/v1/common_pb";
import type {
  Database,
  TableMetadata,
} from "@/types/proto-es/v1/database_service_pb";
import {
  extractDatabaseResourceName,
  getInstanceResource,
  hasSchemaProperty,
} from "@/utils";

export type DatabaseResourceType =
  | "databases"
  | "schemas"
  | "tables"
  | "columns";

export interface DatabaseTreeOption<L = DatabaseResourceType> {
  label: string;
  level: L;
  value: string;
  isLeaf?: boolean;
  disabled?: boolean;
  children?: DatabaseTreeOption[];
}

export const mapTreeOptions = ({
  databaseList,
  filterValueList,
  includeColumn,
}: {
  databaseList: Database[];
  filterValueList?: string[];
  includeColumn: boolean;
}) => {
  const databaseNodes: DatabaseTreeOption<"databases">[] = [];
  const filteredDatabaseList = filterValueList
    ? databaseList.filter((database) =>
        filterValueList.some(
          (value) => value.split("/schemas/")[0] === database.name
        )
      )
    : databaseList;
  for (const database of filteredDatabaseList) {
    const databaseNode: DatabaseTreeOption<"databases"> = {
      level: "databases",
      value: database.name,
      label: extractDatabaseResourceName(database.name).databaseName,
      isLeaf: false,
      children: getSchemaOrTableTreeOptions({
        database,
        filterValueList,
        includeColumn,
      }),
    };
    if (!isUndefined(databaseNode.children)) {
      databaseNode.isLeaf = databaseNode.children.length === 0;
    }

    databaseNodes.push(databaseNode);
  }
  return databaseNodes;
};

const getTableTreeOptions = ({
  prefix,
  tableList,
  filterValueList,
  includeColumn,
}: {
  prefix: string;
  tableList: TableMetadata[];
  filterValueList?: string[];
  includeColumn: boolean;
}): DatabaseTreeOption<"tables">[] => {
  const tableNodes = tableList.map((table): DatabaseTreeOption<"tables"> => {
    const option: DatabaseTreeOption<"tables"> = {
      level: "tables",
      value: `${prefix}/tables/${table.name}`,
      label: table.name,
      isLeaf: true,
    };
    if (includeColumn) {
      option.children = table.columns.map(
        (column): DatabaseTreeOption<"columns"> => ({
          level: "columns",
          value: `${option.value}/columns/${column.name}`,
          label: column.name,
          isLeaf: true,
        })
      );
      if (filterValueList) {
        option.children = option.children.filter((node) =>
          filterValueList.includes(node.value)
        );
      }
    }
    if (option.children && option.children.length > 0) {
      option.isLeaf = false;
    }
    return option;
  });
  return filterValueList
    ? tableNodes.filter((node) =>
        filterValueList.some(
          (value) => value.split("/columns/")[0] === node.value
        )
      )
    : tableNodes;
};

export const getSchemaOrTableTreeOptions = ({
  database,
  filterValueList,
  includeColumn,
}: {
  database: Database;
  filterValueList?: string[];
  includeColumn: boolean;
}) => {
  if (getInstanceResource(database).engine === Engine.MONGODB) {
    // do not support table level select for MongoDB.
    return [];
  }
  const databaseMetadata = useAppStore
    .getState()
    .getCachedDatabaseMetadata(database.name);
  if (!databaseMetadata) {
    return undefined;
  }
  if (hasSchemaProperty(getInstanceResource(database).engine)) {
    const schemaNodes = databaseMetadata.schemas.map(
      (schema): DatabaseTreeOption<"schemas"> => {
        const value = `${database.name}/schemas/${schema.name}`;
        const schemaNode: DatabaseTreeOption<"schemas"> = {
          level: "schemas",
          value,
          label: schema.name,
          children: getTableTreeOptions({
            prefix: value,
            tableList: schema.tables,
            filterValueList,
            includeColumn,
          }),
          isLeaf: true,
        };
        if (schemaNode.children && schemaNode.children.length > 0) {
          schemaNode.isLeaf = false;
        }
        return schemaNode;
      }
    );
    return filterValueList
      ? schemaNodes.filter((node) =>
          filterValueList.some(
            (value) => value.split("/tables/")[0] === node.value
          )
        )
      : schemaNodes;
  } else {
    return getTableTreeOptions({
      prefix: `${database.name}/schemas/`,
      tableList: flatten(
        databaseMetadata.schemas.map((schema) => schema.tables)
      ),
      filterValueList,
      includeColumn,
    });
  }
};

export const flattenTreeOptions = (
  options: DatabaseTreeOption[]
): DatabaseTreeOption[] => {
  return options.flatMap((option) => {
    return [option, ...flattenTreeOptions(option.children ?? [])];
  });
};

export const parseStringToResource = (
  key: string
): DatabaseResource | undefined => {
  // The key starts with either instances/{instance} or
  // projects/{project}/instances/{instance}, followed by a database and
  // optional schema/table/column descendants.
  const sections = key.split("/");
  const resource: DatabaseResource = {
    databaseFullName: "",
  };
  let projectName = "";
  let instanceName = "";

  while (sections.length > 0) {
    const keyword = sections.shift() as
      | DatabaseResourceType
      | "projects"
      | "instances";
    const data = sections.shift() || "";

    switch (keyword) {
      case "projects":
        if (!data) return;
        projectName = `projects/${data}`;
        break;
      case "instances": {
        resource.instanceResourceId = data;
        instanceName = projectName
          ? `${projectName}/instances/${data}`
          : `${instanceNamePrefix}${data}`;
        if (resource.databaseResourceId) {
          resource.databaseFullName = `${instanceName}/${databaseNamePrefix}${resource.databaseResourceId}`;
        }
        break;
      }
      case "databases": {
        resource.databaseResourceId = data;
        if (instanceName) {
          resource.databaseFullName = `${instanceName}/${databaseNamePrefix}${resource.databaseResourceId}`;
        }
        break;
      }
      case "schemas":
        resource.schema = data;
        break;
      case "tables":
        resource.table = data;
        break;
      case "columns":
        if (data) {
          resource.columns = [data];
        }
        break;
      default:
        return;
    }
  }

  if (!resource.databaseFullName) {
    return;
  }

  return resource;
};