@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@syngrisi/syngrisi",
-  "version": "2.2.2",
+  "version": "2.2.6-alpha.0",
   "description": "Syngrisi - Visual Testing Tool",
-  "main": "server.js",
+  "main": "./dist/server/server.js",
+  "type": "commonjs",
   "bin": {
     "sy": "server.js"
   },
@@ -32,15 +33,27 @@
     "screenshots",
     "comparison"
   ],
+  "nodemonConfig": {
+    "ignore": [
+      "mvc/views/lib/*.js"
+    ],
+    "include": [
+      "dist"
+    ],
+    "delay": 500
+  },
   "scripts": {
-    "clean:server": "rm -rf dist",
-    "build:ui": "rm -rf mvc/views/react/assets && cross-env VITE_ROOT_PATH='./src/ui-app/' vite build",
-    "build:server": "npm run clean:server && tsc -b --verbose",
+    "server:watch": "npx tsup --watch --onSuccess \"node ./dist/server/server.js\" # compile all server ts files changes",
+    "start": "if [ \"$NODE_ENV\" = \"development\" ]; then npm run server:watch; else node ./dist/server/server.js; fi",
+    "start_old": "SYNGRISI_AUTH=false nodemon --ignore 'mvc/views/lib/*.js' --ignore 'tests'",
+    "test": "npm run build && cd tests && npm run test",
     "build": "npm run build:ui && npm run build:server",
+    "clean:server": "rimraf dist",
+    "build:ui": "rm -rf mvc/views/react/assets && cross-env VITE_ROOT_PATH='./src/ui-app/' vite build",
+    "build:server": "npm run clean:server&& npx tsup",
     "install:server": "npm i",
     "install:ui": "cd src/ui-app && npm i && cd --",
     "install:all": "npm run install:server && npm run install:ui",
-    "test": "npm run build && cd tests && npm run test",
     "test:docker": "cd tests && npm run test:docker",
     "smoke": "cd tests && npm run smoke",
     "dev": "cross-env VITE_SYNGRISI_BASED_URL='http://localhost:3000' VITE_INDEX_ROUTE='index2/' vite",
@@ -53,7 +66,6 @@
     "tasks:restore": "node dist/src/tasks/restore.js",
     "tasks:migration_2_0": "node src/tasks/migrations/2.0.migration.js",
     "startservice": "forever start -l forever.log -o out.log -e err.log server.js",
-    "start": "nodemon --ignore 'mvc/views/lib/*.js' --ignore 'tests' server.js",
     "clean": "read -p \"Are you sure you want to clean the project? [y/n] \" REPLY; if [[ $REPLY =~ ^[Yy]$ ]]; then mongosh SyngrisiDb --eval \"db.dropDatabase();\" && rm -f ./baselines/*.png; fi",
     "start_test": "cross-env SYNGRISI_DB_URI='mongodb://localhost/SyngrisiDbTest' nodemon server.js",
     "clear_test": "mongosh SyngrisiDbTest$CID --eval \"db.dropDatabase();\" && rm -rf ./baselinesTest/$CID",
@@ -74,8 +86,10 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@asteasolutions/zod-to-openapi": "^7.0.0",
     "@inquirer/prompts": "^3.3.0",
     "@syngrisi/node-resemble.js": "^2.1.36-alpha.0",
+    "@types/compression": "^1.7.5",
     "body-parser": "^1.19.0",
     "bottleneck": "^2.19.5",
     "bson": "^5.5.1",
@@ -84,10 +98,13 @@
     "connect-mongo": "^5.1.0",
     "cookie-parser": "^1.4.6",
     "dotenv": "^16.0.0",
+    "envalid": "^8.0.0",
+    "eslint-plugin-custom-rules": "^0.0.0",
     "express": "^4.18.2",
-    "express-fileupload": "^1.4.0",
+    "express-fileupload": "^1.5.0",
     "express-session": "^1.17.1",
     "hasha": "^5.1.0",
+    "helmet": "^7.1.0",
     "http-status": "^1.5.2",
     "mongoose": "^7.6.4",
     "nodemon": "^3.0.1",
@@ -97,31 +114,45 @@
     "passport-local-mongoose": "^8.0.0",
     "pino": "^8.16.1",
     "pino-http": "^8.5.1",
+    "source-map-support": "^0.5.21",
     "string-table": "^0.1.5",
+    "swagger-ui-express": "^5.0.1",
     "uuid-apikey": "^1.5.2",
     "winston": "^3.11.0",
     "winston-mongodb": "^5.1.1",
-    "zod": "^3.22.4"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@playwright/test": "^1.43.1",
+    "@types/cookie-parser": "^1.4.7",
+    "@types/express": "^4.17.21",
+    "@types/express-fileupload": "^1.5.0",
+    "@types/express-session": "^1.18.0",
     "@types/fabric": "^4.5.12",
     "@types/jquery": "^3.5.14",
     "@types/mongoose": "^5.11.97",
     "@types/node": "^20.9.0",
+    "@types/passport": "^1.0.16",
+    "@types/passport-local": "^1.0.38",
     "@types/react": "^18.0.15",
     "@types/react-dom": "^18.0.6",
-    "@typescript-eslint/eslint-plugin": "^6.11.0",
-    "@typescript-eslint/parser": "^6.11.0",
+    "@types/swagger-ui-express": "^4.1.6",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
     "@vitejs/plugin-react": "^2.0.0",
     "babel-eslint": "^10.1.0",
     "c8": "^8.0.1",
     "cross-env": "^7.0.3",
-    "eslint": "^8.53.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-custom": "file:.eslint",
     "form-data": "^4.0.0",
     "parcel": "^2.10.2",
+    "rimraf": "^5.0.7",
     "sass": "^1.54.0",
+    "tsup": "^8.1.0",
     "typescript": "^5.2.2",
-    "vite": "^3.0.9"
+    "vite": "^3.0.9",
+    "vite-tsconfig-paths": "^4.3.2"
   },
   "nyc": {
     "all": true,
@@ -140,5 +171,5 @@
       ".js"
     ]
   },
-  "gitHead": "c65cb44b70f41cc4e20fa4efdb30a6e6bff654bd"
+  "gitHead": "b1281d2a63a03a85781d81bc6de00c765efdb34d"
 }

package/src/seeds/testAdmin.json

@@ -0,0 +1,10 @@
+{
+	"username" : "Test",
+  "firstName": "Test",
+  "lastName": "Admin",
+	"role" : "admin",
+  "openPassw": "123456aA-",
+	"password" : "5b8d4960316d1fb0c92498c90da6c397cdf247cae71f01467a88e2b42d7af6f5ac7ca75d3bea6e3e0078111a2e5dfc1611f9a9a8908a5a3af5bcd64c42989608977de192829bdf8ada113a60f8f0704443c659789761865e29a3103dbf0773f5bf31e4685d475ece56afaceb949b6e7467eaa287a02e4142d095bcbf84acaefe47ee080799a28188890d39d3397e285d8b46c9a0efe9517428825b64ee1ebcc96d92c084733db866c767341381b6254aaa1ef36d1bf3d24e3f5b8d8b6b4080589b130e9c90914a3da74e5b6adf5f569bfd77460abae8ae4f87c2a375397a37f09861b9e114cead0cc34fff2d631fd4294260dea17e4fe098940dbee2cb80c62eb3701d40f5b204de776b8252d55e5f567c599b1fbcdae79278d1f375a4c8244a26a3b721dbeec56c8f39b3eb810942d392aae371ea81ded6b820dd4b489566a33c495f5c291ff238d07202d2ff04c52426828e44af98ec056a42d13f4b166ec170083e2fff9efe2b8cfdde529f3bce56b8427cf2d188861808ad07fd13e073b2a804e818b2882c13f559d52420b49f301263a9de34fe22b6df4a82ae70e7e4c29c88479878d2c21fbb810532532e7ad9a28f610b63033520e703f178e7b44d3e101ec0d4339c085ccc8bb290b3cb996c75c2b8deaacba8098b9ec02c7e47542891da3bd887c31cd8e0bdfa56bb844b1703368afe8dc42d668ff2e3374b939b4f",
+	"apiKey" : "",
+	"salt" : "c6211751bdc372f491a86bcbd8e4196dc393d14e14e5f17019d5c317afd5bc27"
+}

package/src/server/api-docs/openAPIDocumentGenerator.ts

@@ -0,0 +1,48 @@
+import { OpenApiGeneratorV3, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { registry as users } from '../routes/v1/users.route';
+import { registry as app } from '../routes/v1/app.route';
+
+import { registry as suites } from '../routes/v1/suites.route';
+import { registry as auth } from '../routes/v1/auth.route';
+import { registry as logs } from '../routes/v1/logs.route';
+import { registry as tasks } from '../routes/v1/tasks.route';
+import { registry as baselines } from '../routes/v1/baselines.route';
+import { registry as runs } from '../routes/v1/runs.route';
+import { registry as test } from '../routes/v1/tests.route';
+import { registry as checks } from '../routes/v1/checks.route';
+import { registry as settings } from '../routes/v1/settings.route';
+import { registry as testDistinct } from '../routes/v1/test_distinct.route';
+import { registry as client } from '../routes/v1/client.route';
+import { registry as snapshots } from '../routes/v1/snapshots.route';
+
+export function generateOpenAPIDocument() {
+  const registry = new OpenAPIRegistry([
+    users,
+    app,
+    auth,
+    logs,
+    suites,
+    tasks,
+    baselines,
+    runs,
+    test,
+    checks,
+    settings,
+    testDistinct,
+    client,
+    snapshots
+  ]);
+  const generator = new OpenApiGeneratorV3(registry.definitions);
+
+  return generator.generateDocument({
+    openapi: '3.0.0',
+    info: {
+      version: '1.0.0',
+      title: 'Swagger API',
+    },
+    externalDocs: {
+      description: 'View the raw OpenAPI Specification in JSON format',
+      url: '/swagger.json',
+    },
+  });
+}

package/src/server/api-docs/openAPIResponseBuilders.ts

@@ -0,0 +1,38 @@
+import StatusCodes  from 'http-status';
+import { z } from 'zod';
+import { ServiceResponsePaginationSchema } from './serviceResponse';
+
+export function createApiResponse(schema: z.ZodTypeAny, description: string, statusCode: number = StatusCodes.OK) {
+  return {
+    [statusCode]: {
+      description,
+      content: {
+        'application/json': {
+          schema,
+        },
+      },
+    },
+  };
+}
+
+export function createApiEmptyResponse(description: string, statusCode: number = StatusCodes.OK) {
+  return {
+    [statusCode]: {
+      description,
+    },
+  };
+}
+
+
+export function createPaginatedApiResponse(schema: z.ZodTypeAny, description: string, statusCode:number = StatusCodes.OK) {
+  return {
+    [statusCode]: {
+      description,
+      content: {
+        'application/json': {
+          schema: ServiceResponsePaginationSchema(schema),
+        },
+      },
+    },
+  };
+}

package/src/server/api-docs/openAPIRouter.ts

@@ -0,0 +1,18 @@
+import express, { Request, Response, Router } from 'express';
+import swaggerUi from 'swagger-ui-express';
+import { generateOpenAPIDocument } from './openAPIDocumentGenerator';
+
+export const openAPIRouter: Router = (() => {
+  const router = express.Router();
+  const openAPIDocument = generateOpenAPIDocument();
+
+  // eslint-disable-next-line custom/validate-request-rule, custom/check-route-registration
+  router.get('/json', (_req: Request, res: Response) => {
+    res.setHeader('Content-Type', 'application/json');
+    res.send(openAPIDocument);
+  });
+
+  router.use('/', swaggerUi.serve, swaggerUi.setup(openAPIDocument));
+
+  return router;
+})();

package/src/server/api-docs/serviceResponse.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const ServiceResponsePaginationSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
+  z.object({
+    results: z.array(dataSchema.optional()),
+    page: z.number().openapi({ example: 1 }),
+    limit: z.number().openapi({ example: 10 }),
+    totalPages: z.number().openapi({ example: 2 }),
+    totalResults: z.number().openapi({ example: 12 }),
+    timestamp: z.number().openapi({ example: 1718035239731968 }),
+  });

package/src/server/app.ts

@@ -0,0 +1,77 @@
+import express from 'express';
+import helmet from 'helmet';
+import compression from 'compression';
+import fileUpload from 'express-fileupload';
+import cookieParser from 'cookie-parser';
+import session from 'express-session';
+import MongoStore from 'connect-mongo';
+import passport from 'passport';
+import { Strategy as LocalStrategy } from 'passport-local';
+import path from 'path';
+import log from '@logger';
+import { config } from '@config';
+import routes from './routes/v1/index.route';
+import authRoutes from './routes/ui/auth';
+import adminRoutes from './routes/ui/admin';
+import uiRoutes from './routes/ui';
+
+import { compressionFilter, disableCors } from './middlewares';
+import { User } from './models';
+import httpLogger from '@lib/httpLogger';
+import errorHandler from './middlewares/errorHandler';
+import { openAPIRouter } from './api-docs/openAPIRouter';
+import { LogOpts } from '../types';
+
+const logMeta: LogOpts = { scope: 'app.ts', msgType: "Init" };
+
+log.info('Init the application', logMeta);
+const app = express();
+
+log.info('\t- basic http conf', logMeta);
+
+app.use(helmet(config.helmet));
+app.use(disableCors);
+
+app.use(compression({ filter: compressionFilter }));
+// app.use(bodyParser.urlencoded({ extended: true }));
+
+app.use(express.urlencoded({ extended: true }));
+
+app.use(cookieParser());
+app.use(fileUpload({ limits: { fileSize: config.fileUploadMaxSize } }));
+app.use(express.json({ limit: config.jsonLimit }));
+if (config.enableHttpLogger) app.use(httpLogger);
+
+log.info('\t- authentication', logMeta);
+// Session and Passport setup
+app.use(session({
+  secret: config.storeSessionKey,
+  resave: true,
+  saveUninitialized: false,
+  cookie: { secure: false },
+  store: MongoStore.create({ mongoUrl: config.connectionString }),
+}));
+app.use(passport.initialize());
+app.use(passport.session());
+passport.use(new LocalStrategy({}, User.authenticate()));
+
+passport.serializeUser(User.serializeUser() as ((user: Express.User, done: (err: unknown) => void) => void));
+passport.deserializeUser(User.deserializeUser());
+
+log.info('\t- static files', logMeta);
+const baseDir = process.cwd();
+app.use('/snapshoots', express.static(path.join(baseDir, config.defaultImagesPath)));
+app.use('/assets', express.static(path.join(baseDir, './mvc/views/react/assets')));
+app.use('../static', express.static(path.join(baseDir, './src/server/static/static')));
+
+log.info('\t- routes', logMeta);
+app.use('/v1', routes);
+app.use('/auth', authRoutes);
+app.use('/admin*', adminRoutes);
+app.use('/', uiRoutes);
+
+app.use('/swagger', openAPIRouter);
+
+app.use(errorHandler());
+
+export default app;

package/src/server/config.ts

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import dotenv from 'dotenv';
+import { version } from '@root/package.json';
+import crypto from 'crypto';
+import { env } from "./envConfig";
+
+import devices from "./data/devices.json";
+const customDevicesPath = './server/data/custom_devices.json';
+const logsFolder = './logs';
+dotenv.config();
+
+export const config = {
+    version,
+    // this isn't used 
+    getDevices: async () => {
+        if (fs.existsSync(customDevicesPath)) {
+            return [...devices, ...(await import(customDevicesPath)).default];
+        }
+        return devices;
+    },
+    defaultImagesPath: env.SYNGRISI_IMAGES_PATH,
+    connectionString: env.SYNGRISI_DB_URI || 'mongodb://127.0.0.1:27017/SyngrisiDb',
+    host: env.SYNGRISI_HOSTNAME,
+    port: env.SYNGRISI_APP_PORT || 3000,
+    backupsFolder: './backups',
+    enableHttpLogger: env.SYNGRISI_HTTP_LOG,
+    httpLoggerFilePath: `${logsFolder}/http.log`,
+    storeSessionKey: env.SYNGRISI_SESSION_STORE_KEY || crypto.randomBytes(64).toString('hex'),
+    codeCoverage: env.SYNGRISI_COVERAGE,
+    disableCors: env.SYNGRISI_DISABLE_DEV_CORS,
+    fileUploadMaxSize: 50 * 1024 * 1024,
+    testMode: env.SYNGRISI_TEST_MODE,
+    jsonLimit: '50mb',
+    tmpDir: env.SYNGRISI_TMP_DIR,
+    helmet: {
+        crossOriginEmbedderPolicy: !env.SYNGRISI_DISABLE_DEV_CORS,
+        crossOriginResourcePolicy: !env.SYNGRISI_DISABLE_DEV_CORS,
+        contentSecurityPolicy: {
+            directives: {
+                frameAncestors: ["'self'", "vscode-webview:", "vscode-resource:",  "https:", "http:"],
+                frameSrc: ["'self'", "vscode-webview:", "https:", "http:"],
+                scriptSrc: ["'self'", "'unsafe-inline'"],
+                styleSrc: ["'self'", "'unsafe-inline'"]
+            },
+        },
+    }
+};
+
+if (!fs.existsSync(config.defaultImagesPath)) {
+    fs.mkdirSync(config.defaultImagesPath, { recursive: true });
+}
+
+if (!fs.existsSync(logsFolder)) {
+    fs.mkdirSync(logsFolder, { recursive: true });
+}
+
+

package/src/server/controllers/app.controller.ts

@@ -0,0 +1,23 @@
+import httpStatus from 'http-status';
+import { catchAsync, deserializeIfJSON, pick } from '@utils';
+import { appService } from '@services';
+import { Request, Response } from "express"
+import { config } from "@config";
+
+const info = catchAsync(async (req: Request, res: Response) => {
+    res.status(httpStatus.OK).json({ version: config.version });
+});
+
+const get = catchAsync(async (req: Request, res: Response) => {
+    const filter = typeof req.query.filter === 'string'
+        ? deserializeIfJSON(req.query.filter)
+        : {};
+    const options = pick(req.query, ['sortBy', 'limit', 'page']);
+    const result = await appService.get(filter, options);
+    res.send(result);
+});
+
+export {
+    info,
+    get,
+};

package/src/server/controllers/auth.controller.ts

@@ -0,0 +1,149 @@
+import httpStatus from 'http-status';
+import passport from 'passport';
+import hasha from 'hasha';
+import uuidAPIKey from 'uuid-apikey';
+import { Response, NextFunction } from "express"
+import { User } from '@models';
+import { catchAsync, errMsg } from '@utils';
+import log from "@logger";
+import { RequestUser, ExtRequest } from '@types';
+import { appSettings } from "@settings";
+
+function getApiKey(): string {
+    return uuidAPIKey.create().apiKey;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const apikey = catchAsync(async (req: ExtRequest, res: Response) => {
+    const logOpts = {
+        user: req?.user?.username || undefined,
+        scope: 'apikey',
+        msgType: 'GENERATE_API'
+    };
+
+    const apiKey = getApiKey();
+    log.debug(
+        `generate API Key for user: '${req.user?.username}'`,
+        logOpts
+    );
+    const hash = hasha(apiKey);
+
+    if (!req.user?.username) throw new Error(`Username is empty`);
+
+    const user = await User.findOne({ username: req.user.username });
+    if (!user) throw new Error(`cannot find the user with username: '${req.user.username}'`);
+
+    user.apiKey = hash;
+    await user!.save();
+    res.status(200).json({ apikey: apiKey });
+});
+
+const login = catchAsync(async (req: ExtRequest, res: Response, next: NextFunction) => {
+    const logOpts = {
+        scope: 'login',
+        msgType: 'AUTHENTICATION',
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    passport.authenticate('local', (err: unknown, user: any, info: any) => {
+        if (err) {
+            log.error(`Authentication error: '${err}'`, logOpts);
+            return res.status(httpStatus.UNAUTHORIZED).json({ message: 'authentication error' });
+        }
+        if (!user) {
+            log.error(`Authentication error: '${info.message}'`, logOpts);
+            return res.status(httpStatus.UNAUTHORIZED).json({ message: `Authentication error: '${info.message}'` });
+        }
+
+        req.logIn(user, (e: unknown) => {
+            if (e) {
+                log.error(e, logOpts);
+                return next(e);
+            }
+            log.info('user is logged in', { user: user.username });
+            return res.status(200).json({ message: 'success' });
+        });
+    })(req, res, next);
+});
+
+const logout = catchAsync(async (req: ExtRequest, res: Response) => {
+    const logOpts = {
+        scope: 'logout',
+        msgType: 'AUTHENTICATION',
+    };
+    try {
+        log.debug(`try to log out user: '${req?.user?.username}'`, logOpts);
+        await req.logout({}, () => res.status(httpStatus.OK).json({ message: 'success' }));
+    } catch (e: unknown) {
+        log.error(e, logOpts);
+        res.status(httpStatus.INTERNAL_SERVER_ERROR).json({ message: 'fail' });
+    }
+});
+
+const changePassword = catchAsync(async (req: ExtRequest, res: Response) => {
+    const logOpts = {
+        scope: 'changePassword',
+        msgType: 'CHANGE_PASSWORD',
+        itemType: 'user',
+        ref: req?.user?.username,
+    };
+
+    const { currentPassword, newPassword } = req.body;
+
+    const username = req?.user?.username;
+
+    log.debug(`change password for '${username}', params: '${JSON.stringify(req.body)}'`, logOpts);
+
+    const user: RequestUser | null = await User.findOne({ username });
+    // if (!user) throw new Error(`cannot find user with username: ${username}`);
+
+    if (!user) {
+        log.error('user is not logged in', logOpts);
+        return res.status(httpStatus.UNAUTHORIZED).json({ message: 'user is not logged in' });
+    }
+
+    try {
+        await user.changePassword(currentPassword, newPassword);
+    } catch (e: unknown) {
+        log.error(e, logOpts);
+        return res.status(httpStatus.INTERNAL_SERVER_ERROR).json({ message: errMsg(e) });
+    }
+
+    log.debug(`password was successfully changed for user: ${req.user?.username}`, logOpts);
+    return res.status(200).json({ message: 'success' });
+});
+
+const changePasswordFirstRun = catchAsync(async (req: ExtRequest, res: Response) => {
+    const logOpts = {
+        scope: 'changePasswordFirstRun',
+        msgType: 'CHANGE_PASSWORD_FIRST_RUN',
+        itemType: 'user',
+        ref: req?.user?.username,
+    };
+
+    const { newPassword } = req.body;
+
+    const AppSettings = await appSettings;
+
+    if ((await AppSettings.isAuthEnabled()) && ((await AppSettings.isFirstRun()))) {
+        log.debug(`first run, change password for default 'Administrator', params: '${JSON.stringify(req.body)}'`, logOpts);
+        const user = await User.findOne({ username: 'Administrator' }).exec();
+        if (!user) throw new Error(`cannot find the Administrator`);
+        logOpts.ref = String(user?.username);
+        await user.setPassword(newPassword);
+        await user.save();
+        log.debug('password was successfully changed for default Administrator', logOpts);
+        await AppSettings.set('first_run', false);
+        res.status(200).json({ message: 'success' });
+    } else {
+        log.error(`trying to use first run API with no first run state, auth: '${await AppSettings.isAuthEnabled()}', global settings: '${JSON.stringify(await AppSettings.get('first_run'))}'`, logOpts);
+        res.status(httpStatus.FORBIDDEN).json({ message: 'forbidden' });
+    }
+});
+
+export {
+    login,
+    changePassword,
+    changePasswordFirstRun,
+    logout,
+    apikey,
+};

package/src/server/controllers/baseline.controller.ts

@@ -0,0 +1,32 @@
+import httpStatus from 'http-status';
+import { catchAsync } from '@utils';
+import { genericService } from '@services';
+
+import { deserializeIfJSON, pick } from '@utils';
+import { Response } from "express";
+
+import { ApiError } from '@utils';
+import { ExtRequest } from '@types';
+
+const get = catchAsync(async (req: ExtRequest, res: Response) => {
+    const filter = typeof req.query.filter === 'string'
+    ? deserializeIfJSON(req.query.filter)
+    : {};
+
+    // const filter = req.query.filter ? deserializeIfJSON(pick(req.query, ['filter']).filter) : {};
+    const options = pick(req.query, ['sortBy', 'limit', 'page', 'populate']);
+    const result = await genericService.get('VRSBaseline', filter, options);
+    res.send(result);
+});
+
+const put = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { id } = req.params;
+    if (!id) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot update the baseline - Id not found');
+    const result = await genericService.put('VRSBaseline', id, req.body, req?.user);
+    res.send(result);
+});
+
+export {
+    get,
+    put,
+};