Add controllers callbacks

api/registry/types.ts

@@ -2,5 +2,11 @@ export type {DLSConstructor} from '../../src/registry/common/components/dls/type
 export type {
     OnCreateCollectionError,
     OnCreateCollectionSuccess,
+    OnMoveCollectionError,
+    OnMoveCollectionSuccess,
+    OnMoveCollectionsListError,
+    OnMoveCollectionsListSuccess,
+    OnUpdateCollectionError,
+    OnUpdateCollectionSuccess,
 } from '../../src/registry/common/utils/controllers-callbacks/collections';
 export type {GatewayApi} from '../../src/registry';

src/controllers/collections/create.ts

@@ -35,10 +35,8 @@ export const createCollectionController = async (req: Request, res: Response) =>
         controllersCallbacks: {onCreateCollectionError, onCreateCollectionSuccess},
     } = registry.common.functions.get();
 
-    let result;
-
     try {
-        result = await createCollection(
+        const result = await createCollection(
             {ctx: req.ctx},
             {
                 title: body.title,
@@ -52,15 +50,18 @@ export const createCollectionController = async (req: Request, res: Response) =>
             reqBody: body,
             collection: result.collection.model,
         });
+
+        const formattedResponse = formatCollectionWithOperation(
+            result.collection,
+            result.operation,
+        );
+
+        const {code, response} = await prepareResponseAsync({data: formattedResponse});
+
+        res.status(code).send(response);
     } catch (error) {
         onCreateCollectionError({ctx: req.ctx, reqBody: body, error});
 
         throw error;
     }
-
-    const formattedResponse = formatCollectionWithOperation(result.collection, result.operation);
-
-    const {code, response} = await prepareResponseAsync({data: formattedResponse});
-
-    res.status(code).send(response);
 };

src/controllers/collections/index.ts

@@ -11,8 +11,6 @@ import {
     getCollectionContent,
     getCollectionsListByIds,
     getRootCollectionPermissions,
-    moveCollection,
-    moveCollectionsList,
     updateCollection,
 } from '../../services/new/collection';
 import {
@@ -25,6 +23,8 @@ import {
 import Utils from '../../utils';
 
 import {createCollectionController} from './create';
+import {moveCollectionController} from './move';
+import {moveCollectionsListController} from './moveList';
 
 export default {
     create: createCollectionController,
@@ -171,42 +171,10 @@ export default {
         res.status(code).send(response);
     },
 
-    move: async (req: Request, res: Response) => {
-        const {params, body} = req;
-
-        const result = await moveCollection(
-            {ctx: req.ctx},
-            {
-                collectionId: params.collectionId,
-                parentId: body.parentId as string,
-                title: body.title as Optional<string>,
-            },
-        );
-
-        const formattedResponse = formatCollectionModel(result);
-
-        const {code, response} = await prepareResponseAsync({data: formattedResponse});
-
-        res.status(code).send(response);
-    },
-
-    moveList: async (req: Request, res: Response) => {
-        const {body} = req;
-
-        const result = await moveCollectionsList(
-            {ctx: req.ctx},
-            {
-                collectionIds: body.collectionIds,
-                parentId: body.parentId as string,
-            },
-        );
+    move: moveCollectionController,
 
-        const formattedResponse = formatCollectionModelsList(result);
+    moveList: moveCollectionsListController,
 
-        const {code, response} = await prepareResponseAsync({data: formattedResponse});
-
-        res.status(code).send(response);
-    },
     update: async (req: Request, res: Response) => {
         const {params, body} = req;
 

src/controllers/collections/move.ts

@@ -0,0 +1,81 @@
+import {Request, Response} from '@gravity-ui/expresskit';
+
+import {prepareResponseAsync} from '../../components/response-presenter';
+import {makeSchemaValidator} from '../../components/validation-schema-compiler';
+import {moveCollection} from '../../services/new/collection';
+import {formatCollectionModel} from '../../services/new/collection/formatters';
+
+export type MoveCollectionReqBody = {
+    parentId: Nullable<string>;
+    title?: string;
+};
+
+const validateBody = makeSchemaValidator({
+    type: 'object',
+    required: ['parentId'],
+    properties: {
+        parentId: {
+            type: ['string', 'null'],
+        },
+        title: {
+            type: 'string',
+        },
+    },
+});
+
+export type MoveCollectionReqParams = {
+    collectionId: string;
+};
+
+const validateParams = makeSchemaValidator({
+    type: 'object',
+    required: ['collectionId'],
+    properties: {
+        collectionId: {
+            type: 'string',
+        },
+    },
+});
+
+export const moveCollectionController = async (req: Request, res: Response) => {
+    const body = validateBody<MoveCollectionReqBody>(req.body);
+    const params = validateParams(req.params) as MoveCollectionReqParams;
+
+    const registry = req.ctx.get('registry');
+    const {
+        controllersCallbacks: {onMoveCollectionError, onMoveCollectionSuccess},
+    } = registry.common.functions.get();
+
+    try {
+        const result = await moveCollection(
+            {ctx: req.ctx},
+            {
+                collectionId: params.collectionId,
+                parentId: body.parentId,
+                title: body.title,
+            },
+        );
+
+        onMoveCollectionSuccess({
+            ctx: req.ctx,
+            reqBody: body,
+            reqParams: params,
+            collection: result,
+        });
+
+        const formattedResponse = formatCollectionModel(result);
+
+        const {code, response} = await prepareResponseAsync({data: formattedResponse});
+
+        res.status(code).send(response);
+    } catch (error) {
+        onMoveCollectionError({
+            ctx: req.ctx,
+            reqBody: body,
+            reqParams: params,
+            error,
+        });
+
+        throw error;
+    }
+};

src/controllers/collections/moveList.ts

@@ -0,0 +1,64 @@
+import {Request, Response} from '@gravity-ui/expresskit';
+
+import {prepareResponseAsync} from '../../components/response-presenter';
+import {makeSchemaValidator} from '../../components/validation-schema-compiler';
+import {moveCollectionsList} from '../../services/new/collection';
+import {formatCollectionModelsList} from '../../services/new/collection/formatters';
+
+export type MoveCollectionsListReqBody = {
+    collectionIds: string[];
+    parentId: Nullable<string>;
+};
+
+const validateBody = makeSchemaValidator({
+    type: 'object',
+    required: ['collectionIds', 'parentId'],
+    properties: {
+        collectionIds: {
+            type: 'array',
+            items: {type: 'string'},
+        },
+        parentId: {
+            type: ['string', 'null'],
+        },
+    },
+});
+
+export const moveCollectionsListController = async (req: Request, res: Response) => {
+    const body = validateBody<MoveCollectionsListReqBody>(req.body);
+
+    const registry = req.ctx.get('registry');
+    const {
+        controllersCallbacks: {onMoveCollectionsListError, onMoveCollectionsListSuccess},
+    } = registry.common.functions.get();
+
+    try {
+        const result = await moveCollectionsList(
+            {ctx: req.ctx},
+            {
+                collectionIds: body.collectionIds,
+                parentId: body.parentId,
+            },
+        );
+
+        onMoveCollectionsListSuccess({
+            ctx: req.ctx,
+            reqBody: body,
+            collections: result.collections,
+        });
+
+        const formattedResponse = formatCollectionModelsList(result);
+
+        const {code, response} = await prepareResponseAsync({data: formattedResponse});
+
+        res.status(code).send(response);
+    } catch (error) {
+        onMoveCollectionsListError({
+            ctx: req.ctx,
+            reqBody: body,
+            error,
+        });
+
+        throw error;
+    }
+};

src/controllers/collections/update.ts

@@ -0,0 +1,80 @@
+import {Request, Response} from '@gravity-ui/expresskit';
+
+import {prepareResponseAsync} from '../../components/response-presenter';
+import {makeSchemaValidator} from '../../components/validation-schema-compiler';
+import {updateCollection} from '../../services/new/collection';
+import {formatCollectionModel} from '../../services/new/collection/formatters';
+
+export type UpdateCollectionReqBody = {
+    title?: string;
+    description?: string;
+};
+
+const validateBody = makeSchemaValidator({
+    type: 'object',
+    properties: {
+        title: {
+            type: 'string',
+        },
+        description: {
+            type: 'string',
+        },
+    },
+});
+
+export type UpdateCollectionReqParams = {
+    collectionId: string;
+};
+
+const validateParams = makeSchemaValidator({
+    type: 'object',
+    required: ['collectionId'],
+    properties: {
+        collectionId: {
+            type: 'string',
+        },
+    },
+});
+
+export const updateCollectionController = async (req: Request, res: Response) => {
+    const body = validateBody<UpdateCollectionReqBody>(req.body);
+    const params = validateParams(req.params) as UpdateCollectionReqParams;
+
+    const registry = req.ctx.get('registry');
+    const {
+        controllersCallbacks: {onUpdateCollectionError, onUpdateCollectionSuccess},
+    } = registry.common.functions.get();
+
+    try {
+        const result = await updateCollection(
+            {ctx: req.ctx},
+            {
+                collectionId: params.collectionId,
+                title: body.title,
+                description: body.description,
+            },
+        );
+
+        onUpdateCollectionSuccess({
+            ctx: req.ctx,
+            reqBody: body,
+            reqParams: params,
+            collection: result,
+        });
+
+        const formattedResponse = formatCollectionModel(result);
+
+        const {code, response} = await prepareResponseAsync({data: formattedResponse});
+
+        res.status(code).send(response);
+    } catch (error) {
+        onUpdateCollectionError({
+            ctx: req.ctx,
+            reqBody: body,
+            reqParams: params,
+            error,
+        });
+
+        throw error;
+    }
+};

src/registry/common/functions-map.ts

@@ -8,6 +8,12 @@ import type {ColorPalettesAdminValidator} from './utils/color-palettes/types';
 import type {
     OnCreateCollectionError,
     OnCreateCollectionSuccess,
+    OnMoveCollectionError,
+    OnMoveCollectionSuccess,
+    OnMoveCollectionsListError,
+    OnMoveCollectionsListSuccess,
+    OnUpdateCollectionError,
+    OnUpdateCollectionSuccess,
 } from './utils/controllers-callbacks/collections';
 import type {CheckEmbedding} from './utils/embedding/types';
 import type {
@@ -29,7 +35,13 @@ export const commonFunctionsMap = {
     checkEmbedding: makeFunctionTemplate<CheckEmbedding>(),
 
     controllersCallbacks: {
-        onCreateCollectionSuccess: makeFunctionTemplate<OnCreateCollectionSuccess>(),
         onCreateCollectionError: makeFunctionTemplate<OnCreateCollectionError>(),
+        onCreateCollectionSuccess: makeFunctionTemplate<OnCreateCollectionSuccess>(),
+        onMoveCollectionError: makeFunctionTemplate<OnMoveCollectionError>(),
+        onMoveCollectionSuccess: makeFunctionTemplate<OnMoveCollectionSuccess>(),
+        onMoveCollectionsListError: makeFunctionTemplate<OnMoveCollectionsListError>(),
+        onMoveCollectionsListSuccess: makeFunctionTemplate<OnMoveCollectionsListSuccess>(),
+        onUpdateCollectionError: makeFunctionTemplate<OnUpdateCollectionError>(),
+        onUpdateCollectionSuccess: makeFunctionTemplate<OnUpdateCollectionSuccess>(),
     },
 } as const;