Skip to content

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

chore: update batch request for user (#19131)

ecmadao88da24c6132b
diff --git a/backend/api/v1/user_service.go b/backend/api/v1/user_service.go
index ef5c75e717..20d72a2bfb 100644
--- a/backend/api/v1/user_service.go
+++ b/backend/api/v1/user_service.go
@@ -86,14 +86,35 @@ func (s *UserService) GetUser(ctx context.Context, request *connect.Request[v1pb
// BatchGetUsers get users in batch.
func (s *UserService) BatchGetUsers(ctx context.Context, request *connect.Request[v1pb.BatchGetUsersRequest]) (*connect.Response[v1pb.BatchGetUsersResponse], error) {
- response := &v1pb.BatchGetUsersResponse{}
+ // Extract and validate emails from names
+ emails := make([]string, 0, len(request.Msg.Names))
for _, name := range request.Msg.Names {
- user, err := s.GetUser(ctx, connect.NewRequest(&v1pb.GetUserRequest{Name: name}))
+ email, err := common.GetUserEmail(name)
if err != nil {
+ return nil, connect.NewError(connect.CodeInvalidArgument, err)
+ }
+ if err := validateEndUserEmail(email); err != nil {
return nil, err
}
- response.Users = append(response.Users, user.Msg)
+ emails = append(emails, email)
+ }
+
+ // Batch get from store
+ users, err := s.store.BatchGetUsersByEmails(ctx, emails)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to batch get users"))
}
+
+ // Build a map for quick lookup
+ response := &v1pb.BatchGetUsersResponse{}
+ for _, user := range users {
+ v1User, err := convertToUser(ctx, s.iamManager, user)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert user"))
+ }
+ response.Users = append(response.Users, v1User)
+ }
+
return connect.NewResponse(response), nil
}
diff --git a/backend/store/principal.go b/backend/store/principal.go
index 1242d8d01d..af872c5def 100644
--- a/backend/store/principal.go
+++ b/backend/store/principal.go
@@ -154,6 +154,98 @@ func (s *Store) GetUserByEmail(ctx context.Context, email string) (*UserMessage,
return user, nil
}
+// BatchGetUsersByEmails gets users (of any type) by emails in batch using a single SQL query.
+func (s *Store) BatchGetUsersByEmails(ctx context.Context, emails []string) ([]*UserMessage, error) {
+ if len(emails) == 0 {
+ return nil, nil
+ }
+
+ // Normalize emails to lowercase
+ normalizedEmails := make([]string, len(emails))
+ for i, email := range emails {
+ normalizedEmails[i] = strings.ToLower(email)
+ }
+
+ q := qb.Q().Space(`
+ SELECT
+ id,
+ deleted,
+ email,
+ name,
+ type,
+ password_hash,
+ mfa_config,
+ phone,
+ profile,
+ created_at
+ FROM principal
+ WHERE email = ANY(?)
+ ORDER BY created_at ASC
+ `, normalizedEmails)
+
+ sqlStr, args, err := q.ToSQL()
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to build sql")
+ }
+
+ rows, err := s.GetDB().QueryContext(ctx, sqlStr, args...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+
+ var users []*UserMessage
+ for rows.Next() {
+ var user UserMessage
+ var mfaConfigBytes []byte
+ var profileBytes []byte
+ var typeString string
+ if err := rows.Scan(
+ &user.ID,
+ &user.MemberDeleted,
+ &user.Email,
+ &user.Name,
+ &typeString,
+ &user.PasswordHash,
+ &mfaConfigBytes,
+ &user.Phone,
+ &profileBytes,
+ &user.CreatedAt,
+ ); err != nil {
+ return nil, err
+ }
+ if typeValue, ok := storepb.PrincipalType_value[typeString]; ok {
+ user.Type = storepb.PrincipalType(typeValue)
+ } else {
+ return nil, errors.Errorf("invalid principal type string: %s", typeString)
+ }
+
+ mfaConfig := storepb.MFAConfig{}
+ if err := common.ProtojsonUnmarshaler.Unmarshal(mfaConfigBytes, &mfaConfig); err != nil {
+ return nil, err
+ }
+ user.MFAConfig = &mfaConfig
+
+ profile := storepb.UserProfile{}
+ if err := common.ProtojsonUnmarshaler.Unmarshal(profileBytes, &profile); err != nil {
+ return nil, err
+ }
+ user.Profile = &profile
+
+ users = append(users, &user)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, errors.Wrapf(err, "failed to scan rows")
+ }
+
+ // Update cache
+ for _, user := range users {
+ s.userEmailCache.Add(user.Email, user)
+ }
+
+ return users, nil
+}
+
func (s *Store) StatUsers(ctx context.Context) ([]*UserStat, error) {
q := qb.Q().Space(`
SELECT
diff --git a/frontend/src/components/Member/MembersBindingSelect.vue b/frontend/src/components/Member/MembersBindingSelect.vue
index 053c53b439..bc157377fe 100644
--- a/frontend/src/components/Member/MembersBindingSelect.vue
+++ b/frontend/src/components/Member/MembersBindingSelect.vue
@@ -151,7 +151,7 @@ const memberList = computed(() => {
return props.value.map(convertMemberToFullname);
});
-const convertNameToMember = (fullname: string) => {
+const convertFullnameToMember = (fullname: string) => {
if (fullname.startsWith(groupNamePrefix)) {
const email = extractGroupEmail(fullname);
return getGroupEmailInBinding(email);
@@ -169,7 +169,7 @@ const convertNameToMember = (fullname: string) => {
const onMemberListUpdate = (fullnameList: string[]) => {
const memberListInBinding = uniq(fullnameList)
- .map(convertNameToMember)
+ .map(convertFullnameToMember)
.filter((member) => !!member);
emit("update:value", memberListInBinding);
diff --git a/frontend/src/components/Member/utils.ts b/frontend/src/components/Member/utils.ts
index 49671b36f1..9dab054c9f 100644
--- a/frontend/src/components/Member/utils.ts
+++ b/frontend/src/components/Member/utils.ts
@@ -10,9 +10,7 @@ import {
workloadIdentityToUser,
} from "@/store";
import {
- extractServiceAccountId,
extractUserId,
- extractWorkloadIdentityId,
groupNamePrefix,
serviceAccountNamePrefix,
workloadIdentityNamePrefix,
@@ -76,32 +74,10 @@ const getMemberBinding = (
const fullname = convertMemberToFullname(member);
if (fullname.startsWith(serviceAccountNamePrefix)) {
const sa = serviceAccountStore.getServiceAccount(fullname);
- if (sa) {
- user = serviceAccountToUser(sa);
- } else {
- const email = extractServiceAccountId(fullname);
- user = create(UserSchema, {
- title: email,
- name: fullname,
- email: email,
- userType: UserType.SERVICE_ACCOUNT,
- state: State.DELETED,
- });
- }
+ user = serviceAccountToUser(sa);
} else if (fullname.startsWith(workloadIdentityNamePrefix)) {
const wi = workloadIdentityStore.getWorkloadIdentity(fullname);
- if (wi) {
- user = workloadIdentityToUser(wi);
- } else {
- const email = extractWorkloadIdentityId(fullname);
- user = create(UserSchema, {
- title: email,
- name: fullname,
- email: email,
- userType: UserType.WORKLOAD_IDENTITY,
- state: State.DELETED,
- });
- }
+ user = workloadIdentityToUser(wi);
} else {
user = userStore.getUserByIdentifier(member);
if (!user) {
diff --git a/frontend/src/components/v2/Select/UserSelect.vue b/frontend/src/components/v2/Select/UserSelect.vue
index 689554613f..75214da1f3 100644
--- a/frontend/src/components/v2/Select/UserSelect.vue
+++ b/frontend/src/components/v2/Select/UserSelect.vue
@@ -21,12 +21,7 @@ import { computedAsync } from "@vueuse/core";
import { computed } from "vue";
import { HighlightLabelText } from "@/components/v2";
import { UserNameCell } from "@/components/v2/Model/cells";
-import {
- batchGetOrFetchAccounts,
- getUserFullNameByType,
- type UserFilter,
- useUserStore,
-} from "@/store";
+import { getUserFullNameByType, type UserFilter, useUserStore } from "@/store";
import { allUsersUser } from "@/types";
import { type User, UserType } from "@/types/proto-es/v1/user_service_pb";
import { hasWorkspacePermissionV2 } from "@/utils";
@@ -106,7 +101,7 @@ const additionalOptions = computedAsync(async () => {
}
// Ensure users are fetched into store
- await batchGetOrFetchAccounts(userEmails);
+ await userStore.batchGetOrFetchUsers(userEmails);
// Get all users from store
for (const email of userEmails) {
diff --git a/frontend/src/store/modules/account.ts b/frontend/src/store/modules/account.ts
deleted file mode 100644
index 88a3e706fa..0000000000
--- a/frontend/src/store/modules/account.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { getUserTypeByEmail } from "@/types";
-import { UserType } from "@/types/proto-es/v1/user_service_pb";
-import { useServiceAccountStore } from "./serviceAccount";
-import { useUserStore } from "./user";
-import { useWorkloadIdentityStore } from "./workloadIdentity";
-
-export const batchGetOrFetchAccounts = async (nameList: string[]) => {
- const userStore = useUserStore();
- const serviceAccountStore = useServiceAccountStore();
- const workloadIdentityStore = useWorkloadIdentityStore();
-
- const endUsers: string[] = [];
- const serviceAccounts: string[] = [];
- const workloadIdentities: string[] = [];
-
- for (const name of nameList) {
- const userType = getUserTypeByEmail(name);
- switch (userType) {
- case UserType.SERVICE_ACCOUNT:
- serviceAccounts.push(name);
- break;
- case UserType.WORKLOAD_IDENTITY:
- workloadIdentities.push(name);
- break;
- default:
- endUsers.push(name);
- break;
- }
- }
-
- await Promise.all([
- userStore.batchGetOrFetchUsers(endUsers),
- serviceAccountStore.batchGetOrFetchServiceAccounts(serviceAccounts),
- workloadIdentityStore.batchGetOrFetchWorkloadIdentities(workloadIdentities),
- ]);
-};
diff --git a/frontend/src/store/modules/index.ts b/frontend/src/store/modules/index.ts
index 118cd8d8ac..588d1875f0 100644
--- a/frontend/src/store/modules/index.ts
+++ b/frontend/src/store/modules/index.ts
@@ -7,7 +7,6 @@ export * from "./uistate";
export * from "./sqlReview";
export * from "./idp";
export * from "./user";
-export * from "./account";
export * from "./serviceAccount";
export * from "./workloadIdentity";
export * from "./workspaceApprovalSetting";
diff --git a/frontend/src/store/modules/serviceAccount.ts b/frontend/src/store/modules/serviceAccount.ts
index 0e98796962..9e4a7b9f03 100644
--- a/frontend/src/store/modules/serviceAccount.ts
+++ b/frontend/src/store/modules/serviceAccount.ts
@@ -1,11 +1,9 @@
import { create } from "@bufbuild/protobuf";
import { createContextValues } from "@connectrpc/connect";
-import { uniq } from "lodash-es";
import { defineStore } from "pinia";
import { ref } from "vue";
import { serviceAccountServiceClientConnect } from "@/connect";
import { silentContextKey } from "@/connect/context-key";
-import { serviceAccountBindingPrefix } from "@/types";
import { State } from "@/types/proto-es/v1/common_pb";
import type { ServiceAccount } from "@/types/proto-es/v1/service_account_service_pb";
import {
@@ -57,42 +55,29 @@ export const useServiceAccountStore = defineStore("serviceAccount", () => {
};
const getServiceAccount = (name: string) => {
- return cacheByName.value.get(ensureServiceAccountFullName(name));
+ const validName = ensureServiceAccountFullName(name);
+ const email = extractServiceAccountId(validName);
+ return (
+ cacheByName.value.get(validName) ??
+ create(ServiceAccountSchema, {
+ name,
+ email,
+ state: State.ACTIVE,
+ title: email,
+ })
+ );
};
const getOrFetchServiceAccount = async (name: string, silent = false) => {
- const cached = getServiceAccount(name);
- if (cached) {
- return cached;
+ const validName = ensureServiceAccountFullName(name);
+ if (cacheByName.value.has(validName)) {
+ return cacheByName.value.get(validName)!;
}
- const sa = await fetchServiceAccount(name, silent);
- cacheByName.value.set(name, sa);
+ const sa = await fetchServiceAccount(validName, silent);
+ cacheByName.value.set(sa.name, sa);
return sa;
};
- // TODO(ed): support batch get
- const batchGetOrFetchServiceAccounts = async (nameList: string[]) => {
- const validList = uniq(nameList).filter(
- (name) =>
- Boolean(name) &&
- (name.startsWith(serviceAccountNamePrefix) ||
- name.startsWith(serviceAccountBindingPrefix))
- );
- try {
- const pendingFetch = validList
- .filter((name) => {
- return getServiceAccount(name) === undefined;
- })
- .map((name) => ensureServiceAccountFullName(name));
-
- await Promise.all(
- pendingFetch.map((name) => {
- return getOrFetchServiceAccount(name);
- })
- );
- } catch {}
- };
-
const createServiceAccount = async (
serviceAccountId: string,
serviceAccount: Partial<ServiceAccount>
@@ -183,7 +168,6 @@ export const useServiceAccountStore = defineStore("serviceAccount", () => {
listServiceAccounts,
getServiceAccount,
getOrFetchServiceAccount,
- batchGetOrFetchServiceAccounts,
createServiceAccount,
updateServiceAccount,
deleteServiceAccount,
diff --git a/frontend/src/store/modules/user.ts b/frontend/src/store/modules/user.ts
index 5ce103ce7c..76beee56ae 100644
--- a/frontend/src/store/modules/user.ts
+++ b/frontend/src/store/modules/user.ts
@@ -32,12 +32,7 @@ import {
import { ensureUserFullName, hasWorkspacePermissionV2 } from "@/utils";
import { serviceAccountToUser, useServiceAccountStore } from "./serviceAccount";
import { useActuatorV1Store } from "./v1/actuator";
-import {
- extractUserId,
- serviceAccountNamePrefix,
- userNamePrefix,
- workloadIdentityNamePrefix,
-} from "./v1/common";
+import { extractUserId, userNamePrefix } from "./v1/common";
import { usePermissionStore } from "./v1/permission";
import {
useWorkloadIdentityStore,
@@ -189,37 +184,12 @@ export const useUserStore = defineStore("user", () => {
};
const fetchUser = async (name: string, silent = false) => {
- const email = extractUserId(name);
-
- if (
- email.endsWith("@service.bytebase.com") ||
- email.includes(".service.bytebase.com")
- ) {
- const response = await serviceAccountStore.getOrFetchServiceAccount(
- `${serviceAccountNamePrefix}${email}`,
- silent
- );
- return setUser(serviceAccountToUser(response));
- }
-
- if (
- email.endsWith("@workload.bytebase.com") ||
- email.includes(".workload.bytebase.com")
- ) {
- const response = await workloadIdentityStore.getOrFetchWorkloadIdentity(
- `${workloadIdentityNamePrefix}${email}`,
- silent
- );
- return setUser(workloadIdentityToUser(response));
- }
-
const request = create(GetUserRequestSchema, {
name,
});
- const response = await userServiceClientConnect.getUser(request, {
+ return await userServiceClientConnect.getUser(request, {
contextValues: createContextValues().set(silentContextKey, silent),
});
- return setUser(response);
};
const createUser = async (user: User) => {
diff --git a/frontend/src/store/modules/v1/projectIamPolicy.ts b/frontend/src/store/modules/v1/projectIamPolicy.ts
index 67b1b57895..3ea3a35e8d 100644
--- a/frontend/src/store/modules/v1/projectIamPolicy.ts
+++ b/frontend/src/store/modules/v1/projectIamPolicy.ts
@@ -22,8 +22,8 @@ import type { Project } from "@/types/proto-es/v1/project_service_pb";
import type { User } from "@/types/proto-es/v1/user_service_pb";
import { getDatabaseProject, getUserListInBinding } from "@/utils";
import { convertFromExpr } from "@/utils/issue/cel";
-import { batchGetOrFetchAccounts } from "../account";
import { useRoleStore } from "../role";
+import { useUserStore } from "../user";
import { useCurrentUserV1 } from "./auth";
import { getUserFullNameByType, userNamePrefix } from "./common";
import { useGroupStore } from "./group";
@@ -49,7 +49,7 @@ export const composePolicyBindings = async (
useGroupStore().batchGetOrFetchGroups(groups),
];
if (!skipFetchUsers) {
- requests.push(batchGetOrFetchAccounts(users));
+ requests.push(useUserStore().batchGetOrFetchUsers(users));
}
await Promise.allSettled(requests);
};
diff --git a/frontend/src/store/modules/workloadIdentity.ts b/frontend/src/store/modules/workloadIdentity.ts
index 84609f11c1..3dc1e47b48 100644
--- a/frontend/src/store/modules/workloadIdentity.ts
+++ b/frontend/src/store/modules/workloadIdentity.ts
@@ -1,11 +1,9 @@
import { create } from "@bufbuild/protobuf";
import { createContextValues } from "@connectrpc/connect";
-import { uniq } from "lodash-es";
import { defineStore } from "pinia";
import { ref } from "vue";
import { workloadIdentityServiceClientConnect } from "@/connect";
import { silentContextKey } from "@/connect/context-key";
-import { workloadIdentityBindingPrefix } from "@/types";
import { State } from "@/types/proto-es/v1/common_pb";
import {
type User,
@@ -60,45 +58,32 @@ export const useWorkloadIdentityStore = defineStore("workloadIdentity", () => {
};
const getWorkloadIdentity = (name: string) => {
- return cacheByName.value.get(ensureWorkloadIdentityFullName(name));
+ const validName = ensureWorkloadIdentityFullName(name);
+ const email = extractWorkloadIdentityId(validName);
+ return (
+ cacheByName.value.get(ensureWorkloadIdentityFullName(name)) ??
+ create(WorkloadIdentitySchema, {
+ name,
+ email,
+ state: State.ACTIVE,
+ title: email,
+ })
+ );
};
const getOrFetchWorkloadIdentity = async (
name: string,
silent = false
): Promise<WorkloadIdentity> => {
- const cached = getWorkloadIdentity(name);
- if (cached) {
- return cached;
+ const validName = ensureWorkloadIdentityFullName(name);
+ if (cacheByName.value.has(validName)) {
+ return cacheByName.value.get(validName)!;
}
const wi = await fetchWorkloadIdentity(name, silent);
- cacheByName.value.set(name, wi);
+ cacheByName.value.set(wi.name, wi);
return wi;
};
- // TODO(ed): support batch get
- const batchGetOrFetchWorkloadIdentities = async (nameList: string[]) => {
- const validList = uniq(nameList).filter(
- (name) =>
- Boolean(name) &&
- (name.startsWith(workloadIdentityNamePrefix) ||
- name.startsWith(workloadIdentityBindingPrefix))
- );
- try {
- const pendingFetch = validList
- .filter((name) => {
- return getWorkloadIdentity(name) === undefined;
- })
- .map((name) => ensureWorkloadIdentityFullName(name));
-
- await Promise.all(
- pendingFetch.map((name) => {
- return getOrFetchWorkloadIdentity(name);
- })
- );
- } catch {}
- };
-
const createWorkloadIdentity = async (
workloadIdentityId: string,
workloadIdentity: Partial<WorkloadIdentity>
@@ -195,7 +180,6 @@ export const useWorkloadIdentityStore = defineStore("workloadIdentity", () => {
listWorkloadIdentities,
getWorkloadIdentity,
getOrFetchWorkloadIdentity,
- batchGetOrFetchWorkloadIdentities,
createWorkloadIdentity,
updateWorkloadIdentity,
deleteWorkloadIdentity,