bws-139: + added validation for uuid

backend/src/api/bs/bs.api.ts

@@ -24,7 +24,10 @@ import {
   BSObjectGetRequestParamsDto,
 } from '~/common/types/types';
 import { FastifyRouteSchemaDef } from 'fastify/types/schema';
-import { bsSpaceCreate as bsSpaceCreateValidationSchema } from '~/validation-schemas/validation-schemas';
+import {
+  bsSpaceCreate as bsSpaceCreateValidationSchema,
+  UUID as UUIDValidationSchema,
+} from '~/validation-schemas/validation-schemas';
 import {
   upload as uploadHook,
   checkHasPermissions as checkHasPermissionsHook,
@@ -98,6 +101,18 @@ const initBsApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.DELETE,
     url: `${BSApiPath.SPACES}${SpacesApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_BS),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: BSSpaceDeleteParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{ Params: BSSpaceDeleteParamsDto }>,
       rep: FastifyReply,

backend/src/api/eam/eam.api.ts

@@ -29,6 +29,7 @@ import {
   eamGroupCreate as groupCreateValidationSchema,
   eamWorkerCreateBackend as workerValidationSchema,
   eamGroupUpdate as groupUpdateValidationSchema,
+  UUID as UUIDValidationSchema,
 } from '~/validation-schemas/validation-schemas';
 import { checkHasPermissions as checkHasPermissionsHook } from '~/hooks/hooks';
 import { EAMError } from '~/exceptions/exceptions';
@@ -111,6 +112,7 @@ const initEamApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     url: `${EAMApiPath.GROUPS}${GroupsApiPath.$ID}`,
     schema: {
       body: groupUpdateValidationSchema,
+      params: UUIDValidationSchema,
     },
     validatorCompiler({
       schema,
@@ -138,6 +140,18 @@ const initEamApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
   fastify.route({
     method: HttpMethod.GET,
     url: `${EAMApiPath.GROUPS}${GroupsApiPath.$ID}`,
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: EamGroupGetByIdRequestDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{
         Querystring: EamGroupGetByIdRequestDto;
@@ -191,6 +205,18 @@ const initEamApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
   fastify.route({
     method: HttpMethod.DELETE,
     url: `${EAMApiPath.GROUPS}${GroupsApiPath.$ID}`,
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: EAMGroupDeleteParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{ Params: EAMGroupDeleteParamsDto }>,
       rep,
@@ -206,6 +232,18 @@ const initEamApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
   fastify.route({
     method: HttpMethod.DELETE,
     url: `${EAMApiPath.WORKERS}${WorkersApiPath.$ID}`,
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: EAMWorkerDeleteRequestDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{ Params: EAMWorkerDeleteRequestDto }>,
       rep,

backend/src/api/sc/sc.api.ts

@@ -24,6 +24,7 @@ import { FastifyRouteSchemaDef } from 'fastify/types/schema';
 import {
   scInstanceCreate as scInstanceCreateValidationSchema,
   scInstanceUpdate as scInstanceUpdateValidationSchema,
+  UUID as UUIDValidationSchema,
 } from '~/validation-schemas/validation-schemas';
 import { checkHasPermissions as checkHasPermissionsHook } from '~/hooks/hooks';
 
@@ -56,6 +57,18 @@ const initScApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.GET,
     url: `${SCApiPath.SSH_KEYS}${SshKeysApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SC),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: SCSshKeyGetByIdParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{
         Params: SCSshKeyGetByIdParamsDto;
@@ -89,6 +102,18 @@ const initScApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.DELETE,
     url: `${SCApiPath.INSTANCES}${InstancesApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SC),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: SCInstanceDeleteParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{
         Params: SCInstanceDeleteParamsDto;
@@ -106,6 +131,7 @@ const initScApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SC),
     schema: {
       body: scInstanceUpdateValidationSchema,
+      params: UUIDValidationSchema,
     },
     validatorCompiler({
       schema,

backend/src/api/slc/slc.api.ts

@@ -4,7 +4,10 @@ import {
   slcFunction as slcFunctionServ,
   token as tokenServ,
 } from '~/services/services';
-import { slcFunctionCreate as slcFunctionCreateValidationSchema } from '~/validation-schemas/validation-schemas';
+import {
+  slcFunctionCreate as slcFunctionCreateValidationSchema,
+  UUID as UUIDValidationSchema,
+} from '~/validation-schemas/validation-schemas';
 import {
   HttpCode,
   HttpMethod,
@@ -74,6 +77,18 @@ const initSLCApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.POST,
     url: `${SLCApiPath.SLC_FUNCTIONS}${SLCFunctionApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SLC),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: SLCFunctionLoadParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{
         Params: SLCFunctionRunParamsDto;
@@ -124,6 +139,18 @@ const initSLCApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.GET,
     url: `${SLCApiPath.SLC_FUNCTIONS}${SLCFunctionApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SLC),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: SLCFunctionLoadParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{
         Params: SLCFunctionLoadParamsDto;
@@ -144,6 +171,18 @@ const initSLCApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.DELETE,
     url: `${SLCApiPath.SLC_FUNCTIONS}${SLCFunctionApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SLC),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: SLCFunctionLoadParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{ Params: SLCFunctionDeleteParamsDto }>,
       rep: FastifyReply,
@@ -170,6 +209,18 @@ const initSLCApi: FastifyPluginAsync<Options> = async (fastify, opts) => {
     method: HttpMethod.PUT,
     url: `${SLCApiPath.SLC_FUNCTIONS}${SLCFunctionApiPath.$ID}`,
     preHandler: checkHasPermissionsHook(Permission.MANAGE_SLC),
+    schema: {
+      params: UUIDValidationSchema,
+    },
+    validatorCompiler({
+      schema,
+    }: FastifyRouteSchemaDef<typeof UUIDValidationSchema>) {
+      return (
+        data: SLCFunctionLoadParamsDto,
+      ): ReturnType<typeof UUIDValidationSchema['validate']> => {
+        return schema.validate(data);
+      };
+    },
     async handler(
       req: FastifyRequest<{
         Params: SLCFunctionUpdateParamsDto;

backend/src/validation-schemas/uuid/uuid.ts

@@ -0,0 +1 @@
+export { UUID } from 'bws-shared/validation/validation-schemas';

backend/src/validation-schemas/validation-schemas.ts

@@ -12,3 +12,4 @@ export { bsSpaceCreate } from './bs-space/bs-space';
 export { scInstanceCreate, scInstanceUpdate } from './sc-instance/sc-instance';
 export { slcFunctionCreate } from './slc-function/slc-function';
 export { eamTenantUpdate } from './eam-tenant-update/eam-tenant-update';
+export { UUID } from './uuid/uuid';

shared/src/common/enums/enums.ts

@@ -33,6 +33,8 @@ export {
   SCInstanceValidationMessage,
   SLCFunctionValidationMessage,
   SLCFunctionValidationRule,
+  UUIDValidationRule,
+  UUIDValidationMessage,
 } from './validation/validation';
 export { Permission } from './permissions/permissions';
 export { UserRole } from './roles/roles';

shared/src/common/enums/validation/uuid/uuid-validation-massage.ts

@@ -0,0 +1,6 @@
+const UUIDValidationMessage = {
+  UUID_PATTERN: 'uuid is invalid',
+  UUID_REQUIRE: 'uuid is required',
+} as const;
+
+export { UUIDValidationMessage };

shared/src/common/enums/validation/uuid/uuid-validation-rule.enum.ts

@@ -0,0 +1,6 @@
+const UUIDValidationRule = {
+  UUID_PATTERN:
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+} as const;
+
+export { UUIDValidationRule };

shared/src/common/enums/validation/uuid/uuid.ts

@@ -0,0 +1,2 @@
+export { UUIDValidationMessage } from './uuid-validation-massage';
+export { UUIDValidationRule } from './uuid-validation-rule.enum';

shared/src/common/enums/validation/validation.ts

@@ -26,3 +26,4 @@ export {
   SLCFunctionValidationMessage,
   SLCFunctionValidationRule,
 } from './slc-function/slc-function';
+export { UUIDValidationMessage, UUIDValidationRule } from './uuid/uuid';

shared/src/validation/uuid/uuid.validation-shema.ts

@@ -0,0 +1,19 @@
+import * as Joi from 'joi';
+import { getNameOf } from '~/helpers/helpers';
+import { SLCFunctionLoadParamsDto } from '~/common/types/types';
+import {
+  UUIDValidationRule,
+  UUIDValidationMessage,
+} from '~/common/enums/enums';
+
+const UUID = Joi.object({
+  [getNameOf<SLCFunctionLoadParamsDto>('id')]: Joi.string()
+    .required()
+    .regex(UUIDValidationRule.UUID_PATTERN)
+    .messages({
+      'string.empty': UUIDValidationMessage.UUID_REQUIRE,
+      'string.pattern.base': UUIDValidationMessage.UUID_PATTERN,
+    }),
+});
+
+export { UUID };

shared/src/validation/validation-schemas.ts

@@ -13,3 +13,4 @@ export { bsSpaceCreate } from './bs-space/bs-space';
 export { scInstanceCreate, scInstanceUpdate } from './sc-instance/sc-instance';
 export { slcFunctionCreate } from './slc-function/slc-function';
 export { eamTenantUpdate } from './eam-tenant-update/eam-tenant-update.validation-schema';
+export { UUID } from './uuid/uuid.validation-shema';