Add getEntriesData endpoint

src/components/response-presenter.ts

@@ -30,7 +30,11 @@ export default ({data}: {data: any}): ST.ServiceResponse => {
     };
 };
 
-export async function prepareResponseAsync({data}: {data: any}): Promise<ST.ServiceResponse> {
+export async function prepareResponseAsync<T extends any = any>({
+    data,
+}: {
+    data: T;
+}): Promise<ST.ServiceResponse<T>> {
     const response = await Utils.macrotasksEncodeData(data);
 
     if (response.results) {

src/const/common.ts

@@ -114,17 +114,7 @@ export const RETURN_WORKBOOK_COLUMNS = [
     'createdAt',
 ];
 
-export const ALLOWED_SCOPE_VALUES = [
-    'dataset',
-    'pdf',
-    'folder',
-    'dash',
-    'connection',
-    'widget',
-    'config',
-    'presentation',
-    'report',
-];
+export const ALLOWED_SCOPE_VALUES = Object.values(EntryScope);
 
 export const ID_VARIABLES = [
     'ids',

src/controllers/entries/get-entries-data/constants.ts

@@ -0,0 +1,2 @@
+export const NOT_FOUND_ERROR_CODE = 'NOT_FOUND';
+export const ACCESS_DENIED_ERROR_CODE = 'ACCESS_DENIED';

src/controllers/entries/get-entries-data/index.ts

@@ -0,0 +1,75 @@
+import {AppRouteHandler, Request, Response} from '@gravity-ui/expresskit';
+
+import {ApiTag} from '../../../components/api-docs';
+import {makeReqParser, z, zc} from '../../../components/zod';
+import {CONTENT_TYPE_JSON} from '../../../const';
+import {EntryScope} from '../../../db/models/new/entry/types';
+import {getJoinedEntriesRevisionsByIds} from '../../../services/new/entry';
+
+import type {GetEntriesDataResponseBody} from './response-model';
+import {entriesData} from './response-model';
+
+const requestSchema = {
+    body: z.object({
+        entryIds: zc.encodedIdArray({min: 1, max: 1000}),
+        scope: z.nativeEnum(EntryScope).optional(),
+        type: z.string().optional(),
+        fields: z.string().array().min(1).max(100),
+    }),
+};
+
+export type GetEntriesDataRequestBody = z.infer<typeof requestSchema.body>;
+
+const parseReq = makeReqParser(requestSchema);
+
+const controller: AppRouteHandler = async (
+    req: Request,
+    res: Response<GetEntriesDataResponseBody>,
+) => {
+    const {body} = await parseReq(req);
+
+    const result = await getJoinedEntriesRevisionsByIds(
+        {ctx: req.ctx},
+        {
+            entryIds: body.entryIds,
+            scope: body.scope,
+            type: body.type,
+        },
+    );
+
+    req.ctx.log('FILTERED_FIELDS', {
+        fields: body.fields,
+    });
+
+    const response = entriesData.format({result, entryIds: body.entryIds, fields: body.fields});
+
+    res.status(200).send(response);
+};
+
+controller.api = {
+    summary: 'Get entries data',
+    tags: [ApiTag.Entries],
+    request: {
+        body: {
+            content: {
+                [CONTENT_TYPE_JSON]: {
+                    schema: requestSchema.body,
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: entriesData.schema.description ?? '',
+            content: {
+                [CONTENT_TYPE_JSON]: {
+                    schema: entriesData.schema,
+                },
+            },
+        },
+    },
+};
+
+controller.manualDecodeId = true;
+
+export {controller as getEntriesData};

src/controllers/entries/get-entries-data/response-model.ts

@@ -0,0 +1,94 @@
+import _ from 'lodash';
+
+import {z, zc} from '../../../components/zod';
+import {EntryScope} from '../../../db/models/new/entry/types';
+import type {GetJoinedEntriesRevisionsByIdsResult} from '../../../services/new/entry';
+import Utils from '../../../utils';
+
+import {ACCESS_DENIED_ERROR_CODE, NOT_FOUND_ERROR_CODE} from './constants';
+
+const errorSchema = z.object({
+    error: z.object({
+        code: z.enum([NOT_FOUND_ERROR_CODE, ACCESS_DENIED_ERROR_CODE]),
+    }),
+});
+
+const resultSchema = z.object({
+    result: z.object({
+        scope: z.nativeEnum(EntryScope),
+        type: z.string(),
+        data: z.record(z.unknown()),
+    }),
+});
+
+const schema = z
+    .object({
+        entryId: zc.encodedId(),
+    })
+    .and(z.union([resultSchema, errorSchema]))
+    .array()
+    .describe('Entries data');
+
+type ResponseItemResult = z.infer<typeof resultSchema>['result'];
+
+export type GetEntriesDataResponseBody = z.infer<typeof schema>;
+
+const format = ({
+    result,
+    entryIds,
+    fields,
+}: {
+    result: GetJoinedEntriesRevisionsByIdsResult;
+    entryIds: string[];
+    fields: string[];
+}): GetEntriesDataResponseBody => {
+    const {entries, accessDeniedEntryIds} = result;
+
+    const formattedResult: GetEntriesDataResponseBody = [];
+
+    entryIds.forEach((entryId) => {
+        const entry = entries[entryId];
+        const encodedEntryId = Utils.encodeId(entryId);
+
+        if (entry) {
+            let responseData: ResponseItemResult['data'];
+            const {data, scope, type} = entry;
+
+            if (data) {
+                responseData = fields.reduce<ResponseItemResult['data']>((acc, fieldPath) => {
+                    acc[fieldPath] = _.get(data, fieldPath);
+
+                    return acc;
+                }, {});
+            } else {
+                responseData = {};
+            }
+
+            formattedResult.push({
+                entryId: encodedEntryId,
+                result: {
+                    scope,
+                    type,
+                    data: responseData,
+                },
+            });
+        } else if (accessDeniedEntryIds.includes(entryId)) {
+            formattedResult.push({
+                entryId: encodedEntryId,
+                error: {code: ACCESS_DENIED_ERROR_CODE},
+            });
+        } else {
+            formattedResult.push({
+                entryId: encodedEntryId,
+                error: {code: NOT_FOUND_ERROR_CODE},
+            });
+        }
+    });
+
+    return formattedResult;
+};
+
+export const entriesData = {
+    schema,
+    format,
+};

src/controllers/entries.ts → src/controllers/entries/index.ts

@@ -1,8 +1,8 @@
 import {Request, Response} from '@gravity-ui/expresskit';
 
-import {prepareResponseAsync} from '../components/response-presenter';
-import {US_MASTER_TOKEN_HEADER} from '../const';
-import {EntryScope} from '../db/models/new/entry/types';
+import {prepareResponseAsync} from '../../components/response-presenter';
+import {US_MASTER_TOKEN_HEADER} from '../../const';
+import {EntryScope} from '../../db/models/new/entry/types';
 import {
     DeleteEntryData,
     GetEntryRevisionsData,
@@ -13,9 +13,9 @@ import {
     renameEntry,
     switchRevisionEntry,
     updateEntry,
-} from '../services/entry';
-import EntryService from '../services/entry.service';
-import NavigationService from '../services/navigation.service';
+} from '../../services/entry';
+import EntryService from '../../services/entry.service';
+import NavigationService from '../../services/navigation.service';
 import {
     GetEntryArgs,
     GetEntryMetaPrivateArgs,
@@ -24,15 +24,17 @@ import {
     getEntry,
     getEntryMeta,
     getEntryMetaPrivate,
-} from '../services/new/entry';
+} from '../../services/new/entry';
 import {
     formatEntryModel,
     formatGetEntryMetaPrivateResponse,
     formatGetEntryMetaResponse,
     formatGetEntryResponse,
-} from '../services/new/entry/formatters';
-import * as ST from '../types/services.types';
-import Utils from '../utils';
+} from '../../services/new/entry/formatters';
+import * as ST from '../../types/services.types';
+import Utils from '../../utils';
+
+import {getEntriesData} from './get-entries-data';
 
 export default {
     getEntry: async (req: Request, res: Response) => {
@@ -320,4 +322,6 @@ export default {
 
         res.status(code).send(response);
     },
+
+    getEntriesData,
 };

src/registry/common/components/dls/types.ts

@@ -11,10 +11,10 @@ export interface DLSConstructor {
         checkPermissionsArgs: MT.CheckPermissionDlsConfig,
     ) => Promise<any>;
 
-    checkBulkPermission(
+    checkBulkPermission<E extends object>(
         {ctx, trx}: {ctx: AppContext; trx?: TransactionOrKnex},
-        checkBulkPermissionArgs: MT.CheckBulkPermissionsDlsConfig,
-    ): Promise<any[]>;
+        checkBulkPermissionArgs: MT.CheckBulkPermissionsDlsConfig<E>,
+    ): Promise<Array<E & MT.DlsEntity>>;
 
     addEntity(
         {ctx, trx}: {ctx: AppContext; trx?: TransactionOrKnex},

src/routes.ts

@@ -187,6 +187,11 @@ export function getRoutes(_nodekit: NodeKit, options: GetRoutesOptions) {
             private: true,
         }),
 
+        getEntriesData: makeRoute({
+            route: 'POST /v1/get-entries-data',
+            handler: entriesController.getEntriesData,
+        }),
+
         verifyLockExistence: makeRoute({
             route: 'GET /v1/locks/:entryId',
             handler: locksController.verifyExistence,

src/services/entry/actions/create-in-workbook.ts

@@ -39,7 +39,7 @@ export const validateCreateEntryInWorkbook = makeSchemaValidator({
         },
         scope: {
             type: 'string',
-            enum: ['connection', 'dataset', 'dash', 'widget', 'presentation', 'report'],
+            enum: ['connection', 'dataset', 'dash', 'widget', 'report'],
         },
         type: {
             type: 'string',