Users by ids (#35)

Author: jhoncool

src/controllers/users/get-users-by-ids.ts

@@ -0,0 +1,55 @@
+import {AppRouteHandler, Response} from '@gravity-ui/expresskit';
+
+import {ApiTag} from '../../components/api-docs';
+import {makeReqParser, z, zc} from '../../components/zod';
+import {CONTENT_TYPE_JSON} from '../../constants/content-type';
+import {getUsersByIds} from '../../services/users/get-users-by-Ids';
+
+import {UsersByIdsResponseModel, usersByIdsModel} from './response-models/users-model';
+
+const requestSchema = {
+    body: z.object({
+        subjectIds: zc.decodeIdArray({min: 1, max: 1000}),
+    }),
+};
+
+const parseReq = makeReqParser(requestSchema);
+
+const controller: AppRouteHandler = async (req, res: Response<UsersByIdsResponseModel>) => {
+    const {body} = await parseReq(req);
+
+    const result = await getUsersByIds(
+        {ctx: req.ctx},
+        {
+            subjectIds: body.subjectIds,
+        },
+    );
+
+    res.status(200).send(await usersByIdsModel.format(result));
+};
+
+controller.api = {
+    summary: 'Users list by ids',
+    tags: [ApiTag.Users],
+    request: {
+        body: {
+            content: {
+                [CONTENT_TYPE_JSON]: {
+                    schema: requestSchema.body,
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: usersByIdsModel.schema.description ?? '',
+            content: {
+                [CONTENT_TYPE_JSON]: {
+                    schema: usersByIdsModel.schema,
+                },
+            },
+        },
+    },
+};
+
+export {controller as getUsersByIds};

src/controllers/users/index.ts

@@ -1,11 +1,13 @@
 import {getUserProfile} from './get-user-profile';
+import {getUsersByIds} from './get-users-by-ids';
 import {getUsersList} from './get-users-list';
 import {updateUserPassword} from './update-user-password';
 import {updateUserProfile} from './update-user-profile';
 
 export default {
     getUsersList,
     getUserProfile,
+    getUsersByIds,
     updateUserPassword,
     updateUserProfile,
 };

src/controllers/users/response-models/users-model.ts

@@ -0,0 +1,40 @@
+import {z} from '../../../components/zod';
+import type {getUsersByIds} from '../../../services/users/get-users-by-Ids';
+import {encodeId, macrotasksMap} from '../../../utils/ids';
+
+const userSchema = z
+    .strictObject({
+        userId: z.string(),
+        login: z.string().nullable(),
+        email: z.string().nullable(),
+        firstName: z.string().nullable(),
+        lastName: z.string().nullable(),
+    })
+    .describe('User model');
+
+const schema = z
+    .strictObject({
+        users: userSchema.array(),
+    })
+    .describe('Users by ids');
+
+export type UsersByIdsResponseModel = z.infer<typeof schema>;
+
+const format = async (
+    data: Awaited<ReturnType<typeof getUsersByIds>>,
+): Promise<z.infer<typeof schema>> => {
+    return {
+        users: await macrotasksMap(data.users, (user) => ({
+            userId: encodeId(user.userId),
+            login: user.login,
+            email: user.email,
+            firstName: user.firstName,
+            lastName: user.lastName,
+        })),
+    };
+};
+
+export const usersByIdsModel = {
+    schema,
+    format,
+};

src/routes.ts

@@ -154,6 +154,12 @@ export function getRoutes(_nodekit: NodeKit, options: GetRoutesOptions) {
             apiHeaders: [AUTHORIZATION_HEADER],
             permission: Permission.InstanceUse,
         }),
+        getUsersByIds: makeRoute({
+            route: 'POST /v1/users/get-by-ids',
+            handler: usersController.getUsersByIds,
+            apiHeaders: [AUTHORIZATION_HEADER],
+            permission: Permission.InstanceUse,
+        }),
         getMyUserProfile: makeRoute({
             route: 'GET /v1/users/me/profile',
             handler: usersController.getUserProfile,

src/services/users/get-users-by-Ids.ts

@@ -0,0 +1,37 @@
+import {UserModel, UserModelColumn} from '../../db/models/user';
+import type {BigIntId} from '../../db/types/id';
+import {getReplica} from '../../db/utils/db';
+import {ServiceArgs} from '../../types/service';
+
+export interface GetUsersByIdsArgs {
+    subjectIds: BigIntId[];
+}
+
+export const getUsersByIds = async ({ctx, trx}: ServiceArgs, args: GetUsersByIdsArgs) => {
+    const {subjectIds} = args;
+
+    ctx.log('GET_USERS_BY_IDS', {idsSize: subjectIds.length});
+
+    const users = await UserModel.query(getReplica(trx))
+        .select([
+            UserModelColumn.UserId,
+            UserModelColumn.Login,
+            UserModelColumn.Email,
+            UserModelColumn.FirstName,
+            UserModelColumn.LastName,
+        ])
+        .whereIn(UserModelColumn.UserId, Array.from(new Set(subjectIds)))
+        .limit(1000)
+        .timeout(UserModel.DEFAULT_QUERY_TIMEOUT);
+
+    const userIdToUser: Record<BigIntId, UserModel> = {};
+    for (const user of users) {
+        userIdToUser[user.userId] = user;
+    }
+
+    const result = subjectIds.map((subjectId) => userIdToUser[subjectId]).filter(Boolean);
+
+    ctx.log('GET_USERS_BY_IDS_SUCCESS', {usersSize: result.length});
+
+    return {users: result};
+};

src/tests/int/env/opensource/suites/users/get-users-by-ids.test.ts

@@ -0,0 +1,95 @@
+import pick from 'lodash/pick';
+import request from 'supertest';
+
+import {UserModel, UserModelColumn} from '../../../../../../db/models/user';
+import {encodeId} from '../../../../../../utils/ids';
+import {UserRole, app, auth} from '../../../../auth';
+import {createTestUsers, generateTokens} from '../../../../helpers';
+import {makeRoute} from '../../../../routes';
+
+type CreatedUsers = {
+    user1: ReturnType<typeof pickCreatedUserFields>;
+    user2: ReturnType<typeof pickCreatedUserFields>;
+    user3: ReturnType<typeof pickCreatedUserFields>;
+};
+
+const pickCreatedUserFields = (user: UserModel) => ({
+    ...pick(user, [
+        UserModelColumn.Login,
+        UserModelColumn.Email,
+        UserModelColumn.FirstName,
+        UserModelColumn.LastName,
+    ]),
+    userId: encodeId(user.userId),
+});
+
+describe('Get users by ids', () => {
+    let userTokens = {} as Awaited<ReturnType<typeof generateTokens>>;
+    const createdUsers = {} as CreatedUsers;
+
+    beforeAll(async () => {
+        const user1 = await createTestUsers({
+            login: 'user1',
+            firstName: 'User1',
+            email: '[email protected]',
+            roles: [UserRole.Visitor],
+        });
+        createdUsers['user1'] = pickCreatedUserFields(user1);
+
+        const user2 = await createTestUsers({
+            login: 'user2',
+            firstName: 'User2',
+        });
+        createdUsers['user2'] = pickCreatedUserFields(user2);
+
+        const user3 = await createTestUsers({
+            login: 'user3',
+        });
+        createdUsers['user3'] = pickCreatedUserFields(user3);
+
+        userTokens = await generateTokens({userId: user1.userId});
+    });
+
+    test('Access denied without the token', async () => {
+        const response = await request(app)
+            .post(makeRoute('getUsersByIds'))
+            .send({
+                subjectIds: [createdUsers.user2.userId],
+            });
+        expect(response.status).toBe(401);
+    });
+
+    test('User can get all users', async () => {
+        const response = await auth(request(app).post(makeRoute('getUsersByIds')), {
+            accessToken: userTokens.accessToken,
+        }).send({
+            subjectIds: [
+                createdUsers.user1.userId,
+                createdUsers.user2.userId,
+                createdUsers.user3.userId,
+            ],
+        });
+
+        expect(response.status).toBe(200);
+        expect(response.body).toStrictEqual({
+            users: expect.toIncludeSameMembers([
+                createdUsers['user1'],
+                createdUsers['user2'],
+                createdUsers['user3'],
+            ]),
+        });
+    });
+
+    test('Skip not exists id', async () => {
+        const response = await auth(request(app).post(makeRoute('getUsersByIds')), {
+            accessToken: userTokens.accessToken,
+        }).send({
+            subjectIds: [createdUsers.user1.userId, 'jghw6klpj6tm5'],
+        });
+
+        expect(response.status).toBe(200);
+        expect(response.body).toStrictEqual({
+            users: expect.toIncludeSameMembers([createdUsers['user1']]),
+        });
+    });
+});