@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/routes/v1/{index.js → index.route.ts}

@@ -1,18 +1,18 @@
-const express = require('express');
-const authRoute = require('./auth.route');
-const appRoute = require('./app.route');
-const testsRoute = require('./test.route');
-const usersRoute = require('./users.route');
-const logsRoute = require('./logs.route');
-const runsRoute = require('./runs.route');
-const snapshotRoute = require('./snapshots.route');
-const checkRoute = require('./checks.route');
-const baselinesRoute = require('./baselines.route');
-const suitesRoute = require('./suites.route');
-const settingsRoute = require('./settings.route');
-const testDistinctRoute = require('./test_distinct.route');
-const tasksRoute = require('./tasks.route');
-const clientRoute = require('./client.route');
+import express from 'express';
+import authRoute from './auth.route';
+import appRoute from './app.route';
+import testsRoute from './tests.route';
+import usersRoute from './users.route';
+import logsRoute from './logs.route';
+import runsRoute from './runs.route';
+import snapshotRoute from './snapshots.route';
+import checkRoute from './checks.route';
+import baselinesRoute from './baselines.route';
+import suitesRoute from './suites.route';
+import settingsRoute from './settings.route';
+import testDistinctRoute from './test_distinct.route';
+import tasksRoute from './tasks.route';
+import clientRoute from './client.route';
 
 const router = express.Router();
 
@@ -79,4 +79,4 @@ defaultRoutes.forEach((route) => {
     router.use(route.path, route.route);
 });
 
-module.exports = router;
+export default router;

package/src/server/routes/v1/logs.route.ts

@@ -0,0 +1,65 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as logsController from '@controllers/logs.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { LogGetSchema, LogCreateSchema, LogDistinctSchema, LogCreateRespSchema, LogDistinctResponseSchema } from '@schemas/Logs.schema';
+import { createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { createRequestOpenApiBodySchema } from '@schemas/utils/createRequestOpenApiBodySchema';
+import { createRequestBodySchema } from '@schemas/utils/createRequestBodySchema';
+import StatusCodes from 'http-status';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/logs',
+    summary: "List of logs with pagination, and optional filtering and sorting.",
+    tags: ['Logs'],
+    responses: createPaginatedApiResponse(LogGetSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/logs'),
+    logsController.getLogs as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/logs/distinct',
+    summary: "Get distinct log fields",
+    tags: ['Logs'],
+    request: { query: createRequestQuerySchema(LogDistinctSchema) },
+    responses: createApiResponse(LogDistinctResponseSchema, 'Success'),
+});
+
+router.get(
+    '/distinct',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(LogDistinctSchema), 'get, /v1/logs/distinct'),
+    logsController.distinct as Midleware
+);
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/logs',
+    summary: "Create a new log entry",
+    tags: ['Logs'],
+    request: { body: createRequestOpenApiBodySchema(LogCreateSchema) },
+    responses: createApiResponse(LogCreateRespSchema, 'Success', StatusCodes.CREATED),
+});
+
+router.post(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestBodySchema(LogCreateSchema), 'post, /v1/logs'),
+    logsController.createLog as Midleware
+);
+
+export default router;

package/src/server/routes/v1/runs.route.ts

@@ -0,0 +1,55 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as runController from '@controllers/runs.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { RunResponseSchema } from '@schemas/Runs.schema';
+import { createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { commonValidations } from '@schemas/utils';
+import { getByIdParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+import { ApiErrorSchema } from '@schemas/common/ApiError.schema';
+import StatusCodes from 'http-status';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/runs',
+    summary: "List of runs with pagination, and optional filtering and sorting.",
+    tags: ['Runs'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(RunResponseSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/runs'),
+    runController.get as Midleware
+);
+
+registry.registerPath({
+    method: 'delete',
+    path: '/v1/runs/{id}',
+    summary: "Remove a run by ID",
+    description: "Remove a run by ID",
+    tags: ['Runs'],
+    request: commonValidations.paramsId,
+    responses: {
+        ...createApiResponse(RunResponseSchema, 'Success'),
+        ...createApiResponse(ApiErrorSchema, 'ApiError', StatusCodes.NOT_FOUND),
+    },
+});
+
+router.delete(
+    '/:id',
+    ensureLoggedIn(),
+    validateRequest(getByIdParamsSchema(), 'delete, /v1/runs/{id}'),
+    runController.remove as Midleware
+);
+
+export default router;

package/src/server/routes/v1/settings.route.ts

@@ -0,0 +1,54 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as settingsController from '@controllers/settings.controller';
+import { Midleware } from '@types';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { authorization } from '@middlewares/authorization';
+import { validateRequest } from '@utils/validateRequest';
+import { SettingsNameParamSchema, SettingsResponseSchema, SettingsUpdateSchema } from '@schemas/Settings.schema';
+import { createApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { SkipValid } from '@schemas/SkipValid.schema';
+import { createRequestOpenApiBodySchema } from '@schemas/utils/createRequestOpenApiBodySchema';
+import { createRequestBodySchema } from '@schemas/utils/createRequestBodySchema';
+import { createRequestParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+import { commonValidations } from '@schemas/utils';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/settings',
+    summary: "Get application settings",
+    tags: ['Settings'],
+    responses: createApiResponse(SettingsResponseSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    validateRequest(SkipValid, 'get, /v1/settings'),
+    settingsController.getSettings as Midleware
+);
+
+registry.registerPath({
+    method: 'patch',
+    path: '/v1/settings/{name}',
+    summary: "Update a setting by name",
+    tags: ['Settings'],
+    request: { params: SettingsNameParamSchema, body: createRequestOpenApiBodySchema(SettingsUpdateSchema) },
+    responses: createApiResponse(commonValidations.success, 'Success'),
+});
+
+const validateSchema = createRequestParamsSchema(SettingsNameParamSchema)
+    .merge(createRequestBodySchema(SettingsUpdateSchema));
+router.patch(
+    '/:name',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    validateRequest(validateSchema, 'patch, /v1/settings/{name}'),
+    settingsController.updateSetting as Midleware
+);
+
+export default router;

package/src/server/routes/v1/snapshots.route.ts

@@ -0,0 +1,32 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as snapshotsController from '@controllers/snapshots.controller';
+import { Midleware } from '@types';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { validateRequest } from '@utils/validateRequest';
+import { SnapshotsResponseSchema } from '@schemas/Snapshots.schema'
+import { createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/snapshots',
+    summary: "List of snapshots with pagination, and optional filtering and sorting.",
+    tags: ['Snapshots'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(SnapshotsResponseSchema, 'Success'),
+
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/snapshots'),
+    snapshotsController.get as Midleware
+);
+
+export default router;

package/src/server/routes/v1/suites.route.ts

@@ -0,0 +1,52 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as suiteController from '@controllers/suite.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { SuiteGetSchema } from '@schemas/Suite.schema';
+import { createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { commonValidations } from '@schemas/utils';
+import { getByIdParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+import { SkipValid } from '@schemas/SkipValid.schema';
+import { ApiErrorSchema } from '@schemas/common/ApiError.schema';
+import StatusCodes from 'http-status';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/suites',
+    summary: "List of suites",
+    tags: ['Suites'],
+    responses: createPaginatedApiResponse(SuiteGetSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(SkipValid, 'get, /v1/suites'),
+    suiteController.get as Midleware
+);
+
+registry.registerPath({
+    method: 'delete',
+    path: '/v1/suites/{id}',
+    summary: "Delete a suite by ID",
+    tags: ['Suites'],
+    request: commonValidations.paramsId,
+    responses: {
+        ...createApiResponse(SuiteGetSchema, 'Success'),
+        ...createApiResponse(ApiErrorSchema, 'ApiError', StatusCodes.NOT_FOUND),
+    },
+});
+
+router.delete(
+    '/:id',
+    ensureLoggedIn(),
+    validateRequest(getByIdParamsSchema(), 'delete, /v1/suites/{id}'),
+    suiteController.remove as Midleware
+);
+
+export default router;

package/src/server/routes/v1/tasks.route.ts

@@ -0,0 +1,121 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as tasksController from '@controllers/tasks.controller';
+import { Midleware } from '@types';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { authorization } from '@middlewares';
+import { SkipValid } from '@schemas/SkipValid.schema';
+import { validateRequest } from '@utils/validateRequest';
+import { createApiResponse } from '@api-docs/openAPIResponseBuilders';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/task_test',
+    summary: "Test task endpoint",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/task_test',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    validateRequest(SkipValid, 'get, /v1/tasks/task_test'),
+    tasksController.task_test as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/task_handle_old_checks',
+    summary: "Handle old checks task",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/task_handle_old_checks',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    validateRequest(SkipValid, 'get, /v1/tasks/task_handle_old_checks'),
+    tasksController.task_handle_old_checks as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/task_handle_database_consistency',
+    summary: "Handle database consistency task",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/task_handle_database_consistency',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    validateRequest(SkipValid, 'get, /v1/tasks/task_handle_database_consistency'),
+    tasksController.task_handle_database_consistency as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/task_remove_old_logs',
+    summary: "Remove old logs task",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/task_remove_old_logs',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    validateRequest(SkipValid, 'get, /v1/tasks/task_remove_old_logs'),
+    tasksController.task_remove_old_logs as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/loadTestUser',
+    summary: "Load test user",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/loadTestUser',
+    ensureLoggedIn() as Midleware,
+    validateRequest(SkipValid, 'get, /v1/tasks/loadTestUser'),
+    tasksController.loadTestUser as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/status',
+    summary: "Get status task, only for the test cases",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/status',
+    validateRequest(SkipValid, 'get, /v1/tasks/status'),
+    tasksController.status as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tasks/screenshots',
+    summary: "Get screenshots task",
+    tags: ['Tasks'],
+    responses: createApiResponse(SkipValid, 'Success'),
+});
+
+router.get(
+    '/screenshots',
+    validateRequest(SkipValid, 'get, /v1/tasks/screenshots'),
+    tasksController.screenshots as Midleware
+);
+
+export default router;

package/src/server/routes/v1/test_distinct.route.ts

@@ -0,0 +1,32 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as testController from '@controllers/test.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { TestDistinctRequestParamsSchema, TestDistinctResponseSchema } from '@schemas/TestDistinct.schema';
+import { createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { createRequestParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/test-distinct/{id}',
+    summary: "[Obsolete use '/v1/test/distict' instead] List of certain unique fields across all tests",
+    tags: ['Tests'],
+    request: { params: TestDistinctRequestParamsSchema, query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(TestDistinctResponseSchema, 'Success'),
+});
+
+// TODO: [Obsolete] use '/v1/test/distict' instead of this
+router.get(
+    '/:id',
+    ensureLoggedIn(),
+    validateRequest(createRequestParamsSchema(TestDistinctRequestParamsSchema), 'get, /v1/test-distinct/{id}'),
+    testController.distinct as Midleware
+);
+
+export default router;

package/src/server/routes/v1/tests.route.ts

@@ -0,0 +1,90 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as testController from '@controllers/test.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { TestDistinctRequestFieldParamsSchema, TestGetSchema } from '@schemas/Test.schema';
+import { createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { commonValidations } from '@schemas/utils';
+import { createRequestParamsSchema, getByIdParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+import { TestDistinctResponseSchema } from '@schemas/TestDistinct.schema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tests',
+    summary: "Get list of tests",
+    tags: ['Tests'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(TestGetSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/checks'),
+    testController.getTest as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/tests/distinct/{field}',
+    summary: "List of certain unique fields across all tests",
+    tags: ['Tests'],
+    request: { params: TestDistinctRequestFieldParamsSchema, query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(TestDistinctResponseSchema, 'Success'),
+});
+
+router.get(
+    '/distinct/:field',
+    ensureLoggedIn(),
+    validateRequest(
+        createRequestParamsSchema(TestDistinctRequestFieldParamsSchema)
+            .merge(createRequestQuerySchema(RequestPaginationSchema)
+            ),
+        'get, /distinct/:field'
+    ),
+    testController.distinct_with_filter as Midleware
+);
+
+registry.registerPath({
+    method: 'delete',
+    path: '/v1/tests/{id}',
+    summary: "Delete a test by ID",
+    tags: ['Tests'],
+    request: commonValidations.paramsId,
+    responses: createApiResponse(TestGetSchema, 'Success'),
+});
+
+router.delete(
+    '/:id',
+    ensureLoggedIn(),
+    // validateRequest(getByIdParamsSchema(), '/v1/runs/{id}'),
+
+    validateRequest(getByIdParamsSchema(), 'delete, /v1/tests/{id}'),
+    testController.remove as Midleware
+);
+
+registry.registerPath({
+    method: 'put',
+    path: '/v1/tests/accept/{id}',
+    summary: "Accept a test by ID",
+    tags: ['Tests'],
+    request: commonValidations.paramsId,
+    // request: { params: TestDistinctRequestParamsSchema, body: createRequestOpenApiBodySchema(TestAcceptSchema) },
+    responses: createApiResponse(commonValidations.success, 'Success'),
+});
+
+router.put(
+    '/accept/:id',
+    ensureLoggedIn(),
+    validateRequest(getByIdParamsSchema(), 'put, /v1/tests/accept/{id}'),
+    testController.accept as Midleware
+);
+
+export default router;

package/src/server/routes/v1/users.route.ts

@@ -0,0 +1,115 @@
+import express from 'express';
+import StatusCodes from 'http-status';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { Midleware } from '@types';
+import { usersController } from '@controllers';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { authorization } from '@middlewares';
+import { validateRequest } from '@utils/validateRequest';
+import { UserCreateReqSchema, UserCreateRespSchema, UserCurrentRespSchema, UserGetRespSchema, UserSchema } from '@schemas/User.schema';
+import { SkipValid } from '@schemas/SkipValid.schema';
+import { createApiEmptyResponse, createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { createRequestOpenApiBodySchema } from '@schemas/utils/createRequestOpenApiBodySchema';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { createRequestBodySchema } from '@schemas/utils/createRequestBodySchema';
+import { getByIdParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/users/current',
+    summary: 'Retrieve current user details.',
+    tags: ['Users'],
+    responses: createApiResponse(UserCurrentRespSchema, 'Success'),
+});
+
+router.get('/current',
+    validateRequest(SkipValid, 'get, /v1/users/current'),
+    usersController.current as Midleware);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/users/',
+    summary: 'List users with pagination, and optional filtering and sorting.',
+    tags: ['Users'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(UserSchema, 'Success'),
+});
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/users/',
+    summary: 'Create a new user.',
+    tags: ['Users'],
+    request: { body: createRequestOpenApiBodySchema(UserCreateReqSchema) },
+    responses: createApiResponse(UserCreateRespSchema, 'Success'),
+});
+
+router
+    .route('/')
+    .get(
+        ensureLoggedIn(),
+        authorization('user') as Midleware,
+        validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/users/'),
+        usersController.get as Midleware
+    )
+    .post(
+        ensureLoggedIn(),
+        authorization('admin') as Midleware,
+        validateRequest(createRequestBodySchema(UserCreateReqSchema), 'post, /v1/users/'),
+        usersController.create as Midleware
+    );
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/users/{userId}',
+    summary: 'Retrieve user details by user ID.',
+    tags: ['Users'],
+    request: {params: getByIdParamsSchema('userId')},
+    responses: createApiResponse(UserGetRespSchema, 'Success'),
+});
+
+registry.registerPath({
+    method: 'patch',
+    path: '/v1/users/{userId}',
+    summary: 'Update user details by user ID.',
+    tags: ['Users'],
+    request: { params: getByIdParamsSchema('userId'), body: createRequestOpenApiBodySchema(UserSchema) },
+    responses: createApiResponse(UserGetRespSchema, 'Success'),
+});
+
+registry.registerPath({
+    method: 'delete',
+    path: '/v1/users/{userId}',
+    summary: 'Remove user by user ID.',
+    tags: ['Users'],
+    request: { params: getByIdParamsSchema('userId') },
+    responses: createApiEmptyResponse('No Content', StatusCodes.NO_CONTENT),
+});
+
+router
+    .route('/:userId')
+    .get(
+        ensureLoggedIn(),
+        authorization('admin') as Midleware,
+        validateRequest(getByIdParamsSchema('userId'), 'get, /v1/users/{userId}'),
+        usersController.getById as Midleware
+    )
+    .patch(
+        ensureLoggedIn(),
+        authorization('admin') as Midleware,
+        validateRequest(getByIdParamsSchema('userId'), 'patch, /v1/users/{userId}'),
+        usersController.update as Midleware
+    )
+    .delete(
+        ensureLoggedIn(),
+        authorization('admin') as Midleware,
+        validateRequest(getByIdParamsSchema('userId'), 'delete, /v1/users/{userId}'),
+
+        usersController.remove as Midleware
+    );
+
+export default router;