@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/controllers/{check.controller.js → check.controller.ts}

@@ -1,12 +1,15 @@
-const httpStatus = require('http-status');
-const ApiError = require('../utils/ApiError');
-const catchAsync = require('../utils/catchAsync');
-const { genericService, checkService } = require('../services');
-const { deserializeIfJSON, pick } = require('../utils');
-const { removeEmptyProperties } = require('../utils/utils');
-
-const get = catchAsync(async (req, res) => {
-    const filter = req.query.filter ? deserializeIfJSON(pick(req.query, ['filter']).filter) : {};
+import httpStatus from 'http-status';
+import { ApiError, catchAsync, deserializeIfJSON, pick, removeEmptyProperties } from '@utils';
+import { genericService, checkService } from '@services';
+import { ExtRequest } from '@types';
+import { Response } from "express";
+
+const get = catchAsync(async (req: ExtRequest, res: Response) => {
+    // const filter = req.query.filter ? deserializeIfJSON(pick(req.query, ['filter']).filter) : {};
+    const filter = typeof req.query.filter === 'string'
+    ? deserializeIfJSON(req.query.filter)
+    : {};
+
     if (req.user?.role === 'user') {
         filter.creatorUsername = req.user?.username;
     }
@@ -16,14 +19,14 @@ const get = catchAsync(async (req, res) => {
     res.send(result);
 });
 
-const getViaPost = catchAsync(async (req, res) => {
+const getViaPost = catchAsync(async (req: ExtRequest, res: Response) => {
     const filter = req.body.filter ? pick(req.body, ['filter']).filter : {};
     const options = req.body.options ? pick(req.body, ['options']).options : {};
     const result = await genericService.get('VRSCheck', filter, options);
     res.send(result);
 });
 
-const update = catchAsync(async (req, res) => {
+const update = catchAsync(async (req: ExtRequest, res: Response) => {
     const { id } = req.params;
     if (!id) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot accept the check - Id not found');
     const opts = removeEmptyProperties(req.body);
@@ -32,7 +35,7 @@ const update = catchAsync(async (req, res) => {
     res.send(result);
 });
 
-const accept = catchAsync(async (req, res) => {
+const accept = catchAsync(async (req: ExtRequest, res: Response) => {
     const { id } = req.params;
     if (!id) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot accept the check - Id not found');
     if (!req.body.baselineId) throw new ApiError(httpStatus.BAD_REQUEST, `Cannot accept the check: ${id} - new Baseline Id not found`);
@@ -40,14 +43,14 @@ const accept = catchAsync(async (req, res) => {
     res.send(result);
 });
 
-const remove = catchAsync(async (req, res) => {
+const remove = catchAsync(async (req: ExtRequest, res: Response) => {
     const { id } = req.params;
     if (!id) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot remove the check - Id not found');
     const result = await checkService.remove(id, req?.user);
     res.send(result);
 });
 
-module.exports = {
+export {
     getViaPost,
     get,
     accept,

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

@@ -0,0 +1,134 @@
+import httpStatus from 'http-status';
+import { ApiError, catchAsync, pick, deserializeIfJSON, paramsGuard } from '@utils';
+import { clientService, genericService } from '@services';
+import { updateItem } from '@lib/dbItems';
+import { RequiredIdentOptionsSchema, RequiredIdentOptionsType, createCheckParamsSchema } from '@schemas';
+import { User, Test, App, Suite } from '@models';
+import { Response } from "express";
+import log from "../lib/logger";
+import { ExtRequest } from '@types';
+import { ClientStartSessionType } from '../schemas/Client.schema';
+import { CreateCheckParams } from '../services/client.service';
+
+const startSession = catchAsync(async (req: ExtRequest, res: Response) => {
+    const params = pick(
+        req.body,
+        ['name', 'status', 'app', 'tags', 'branch', 'viewport', 'browser', 'browserVersion', 'browserFullVersion',
+            'os', 'run', 'runident', 'suite']
+    ) as ClientStartSessionType;
+    const result = await clientService.startSession(params, String(req?.user?.username));
+    res.send(result);
+});
+
+const endSession = catchAsync(async (req: ExtRequest, res: Response) => {
+    const testId = req.params.testid;
+    if (!testId || testId === 'undefined') {
+        throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot stop test Session testId is empty');
+    }
+
+    const result = await clientService.endSession(testId, String(req?.user?.username));
+    res.send(result);
+});
+
+const createCheck = catchAsync(async (req: ExtRequest, res: Response) => {
+    const params = req.body;
+    paramsGuard(params, 'createCheck, params', createCheckParamsSchema);
+
+    const apiKey = req.headers.apikey;
+    const currentUser = await User.findOne({ apiKey });
+    if (!currentUser) throw new ApiError(httpStatus.NOT_FOUND, `cannot get current user by API`);
+
+
+    const logOpts = {
+        scope: 'createCheck',
+        user: currentUser.username,
+        itemType: 'check',
+        msgType: 'CREATE',
+    };
+
+    log.info(`start to create check: '${params.name}'`, logOpts);
+
+    log.debug(`try to find test with id: '${params.testid}'`, logOpts);
+    const test = await Test.findById(params.testid);
+    if (!test) {
+        const errMsg = `can't find test with id: '${params.testid}', `
+            + `parameters: '${JSON.stringify(req.body)}', username: '${currentUser.username}', apiKey: ${apiKey}`;
+        // res.status(400).send({ status: 'testNotFound', message: errMsg });
+        throw new ApiError(httpStatus.NOT_FOUND, errMsg);
+    }
+    const app = await App.findOne({ name: params.appName });
+    if (!app) throw new ApiError(httpStatus.NOT_FOUND, `cannot get the app: ${params.appName}`);
+    const suite = await Suite.findOne({ name: params.suitename });
+    if (!suite) throw new ApiError(httpStatus.NOT_FOUND, `cannot get the suite: ${params.suitename}`);
+
+    await updateItem('VRSTest', { _id: test.id }, {
+        suite: suite.id,
+        creatorId: currentUser._id,
+        creatorUsername: currentUser.username,
+    });
+
+    const result = await clientService.createCheck(
+        {
+            branch: params.branch,
+            hashCode: params.hashcode,
+            // testId: params.testid,
+            name: params.name,
+            viewport: params.viewport,
+            browserName: params.browserName,
+            browserVersion: params.browserVersion,
+            browserFullVersion: params.browserFullVersion,
+            os: params.os,
+            files: req.files,
+            domDump: params.domdump,
+            vShifting: params.vShifting,
+        } as CreateCheckParams,
+        test,
+        suite,
+        app,
+        currentUser
+    );
+    if (result.status === 'needFiles') {
+        res.status(206).json({
+            status: 'requiredFileData',
+            message: 'could not find a snapshot with such a hash code, please add image file data and resend request',
+            hashCode: params.hashcode,
+        });
+        return;
+    }
+    res.json(result);
+});
+
+const getIdent = catchAsync(async (req: ExtRequest, res: Response) => {
+    const result = clientService.getIdent();
+    res.send(result);
+});
+
+const getBaselines = catchAsync(async (req: ExtRequest, res: Response) => {
+    const filter = pick(
+        (req.query.filter ? deserializeIfJSON(String(req.query.filter)) : {}),
+        ['name', 'viewport', 'browserName', 'os', 'app', 'branch']
+    ) as RequiredIdentOptionsType;
+    paramsGuard(filter, 'getBaseline, filter', RequiredIdentOptionsSchema);
+    const options = pick(req.query, ['sortBy', 'limit', 'page', 'populate']);
+    const result = await clientService.getBaselines(filter, options);
+    res.send(result);
+});
+
+const getSnapshots = catchAsync(async (req: ExtRequest, res: Response) => {
+    const filter = pick(
+        (req.query.filter ? deserializeIfJSON(String(req.query.filter)) : {}),
+        ['_id', 'name', 'imghash', 'createdDate', 'filename', 'id']
+    );
+    const options = pick(req.query, ['sortBy', 'limit', 'page', 'populate']);
+    const result = await genericService.get('VRSSnapshot', filter, options);
+    res.send(result);
+});
+
+export {
+    startSession,
+    endSession,
+    createCheck,
+    getIdent,
+    getBaselines,
+    getSnapshots,
+};

package/src/server/controllers/index.ts

@@ -0,0 +1,27 @@
+import * as baselineController from './baseline.controller';
+import * as checkController from './check.controller';
+import * as clientController from './client.controller';
+import * as logsController from './logs.controller';
+import * as snapshotsController from './snapshots.controller';
+import * as tasksController from './tasks.controller';
+import * as testController from './test.controller';
+import * as usersController from './users.controller';
+import * as appController from './app.controller';
+import * as settingsController from './settings.controller';
+import * as runsController from './runs.controller';
+import * as suiteController from './suite.controller';
+
+export {
+    baselineController,
+    checkController,
+    clientController,
+    logsController,
+    snapshotsController,
+    tasksController,
+    testController,
+    usersController,
+    appController,
+    settingsController,
+    runsController,
+    suiteController,
+};

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

@@ -0,0 +1,36 @@
+import httpStatus from 'http-status';
+import { EJSON } from 'bson';
+import { catchAsync } from '@utils';
+import { logsService } from '@services';
+import { Response } from "express";
+
+import { pick } from '@utils';
+import { ExtRequest } from '@types';
+
+const getLogs = catchAsync(async (req: ExtRequest, res: Response) => {
+    // const filter = req.query.filter ? EJSON.parse(pick(req.query, ['filter']).filter) : {};
+    const filter = typeof req.query.filter === 'string'
+    ? EJSON.parse(req.query.filter)
+    : {};
+
+    const options = pick(req.query, ['sortBy', 'limit', 'page']);
+    const result = await logsService.queryLogs(filter, options);
+    res.send(result);
+});
+
+const distinct = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { field } = pick(req.query, ['field']);
+    const result = await logsService.distinct(String(field));
+    res.send(result);
+});
+
+const createLog = catchAsync(async (req: ExtRequest, res: Response) => {
+    const user = await logsService.createLogs(req.body);
+    res.status(httpStatus.CREATED).send(user);
+});
+
+export {
+    getLogs,
+    distinct,
+    createLog,
+};

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

@@ -0,0 +1,32 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import httpStatus from 'http-status';
+import { EJSON } from 'bson';
+import { catchAsync, pick } from '@utils';
+import { genericService, runService } from '@services';
+import { ExtRequest } from '@types';
+import { Response } from "express";
+
+
+const get = catchAsync(async (req: ExtRequest, res: Response) => {
+    // const filter = req.query.filter ? EJSON.parse(pick(req.query, ['filter']).filter) : {};
+    const filter = typeof req.query.filter === 'string'
+    ? EJSON.parse(req.query.filter)
+    : {};
+
+    const options = pick(req.query, ['sortBy', 'limit', 'page']);
+    const result = await genericService.get('VRSRun', filter, options);
+    res.send(result);
+});
+
+const remove = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { id } = req.params;
+    if (!req.user) throw new Error("req.user is empty");
+
+    const result = await runService.remove(id, req?.user);
+    res.send(result);
+});
+
+export {
+    get,
+    remove,
+};

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

@@ -0,0 +1,28 @@
+import { ExtRequest } from '@types';
+import { catchAsync } from '@utils';
+import { Response } from "express";
+import { appSettings } from "@settings";
+
+const getSettings = catchAsync(async (req: ExtRequest, res: Response) => {
+    const AppSettings = await appSettings;
+    const result = AppSettings.cache;
+    res.json(result);
+});
+
+const updateSetting = catchAsync(async (req: ExtRequest, res: Response) => {
+    const AppSettings = await appSettings;
+
+    const { name } = req.params;
+    await AppSettings.set(name, req.body.value);
+    if (req.body.enabled === false) {
+        await AppSettings.disable(name);
+    } else {
+        await AppSettings.enable(name);
+    }
+    res.json({ message: 'success' });
+});
+
+export {
+    getSettings,
+    updateSetting,
+};

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

@@ -0,0 +1,24 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import httpStatus from 'http-status';
+import { EJSON } from 'bson';
+import { catchAsync } from '@utils';
+import { genericService } from '@services';
+import { Response } from "express";
+
+import { pick } from '@utils';
+import { ExtRequest } from '@types';
+
+const get = catchAsync(async (req: ExtRequest, res: Response) => {
+    // const filter = req.query.filter ? EJSON.parse(pick(req.query, ['filter']).filter) : {};
+    const filter = typeof req.query.filter === 'string'
+    ? EJSON.parse(req.query.filter)
+    : {};
+
+    const options = pick(req.query, ['sortBy', 'limit', 'page']);
+    const result = await genericService.get('VRSSnapshot', filter, options);
+    res.send(result);
+});
+
+export {
+    get,
+};

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

@@ -0,0 +1,30 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import httpStatus from 'http-status';
+import { EJSON } from 'bson';
+import { catchAsync, pick } from '@utils';
+import { genericService, suiteService } from '@services';
+import { Response } from "express";
+import { ExtRequest } from '@types';
+
+const get = catchAsync(async (req: ExtRequest, res: Response) => {
+    // const filter = req.query.filter ? EJSON.parse(pick(req.query, ['filter']).filter) : {};
+    const filter = typeof req.query.filter === 'string'
+    ? EJSON.parse(req.query.filter)
+    : {};
+
+    const options = pick(req.query, ['sortBy', 'limit', 'page']);
+    const result = await genericService.get('VRSSuite', filter, options);
+    res.send(result);
+});
+
+const remove = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { id } = req.params;
+    if(!req.user) throw new Error("req.user is empty");
+    const result = await suiteService.remove(id, req?.user);
+    res.send(result);
+});
+
+export {
+    get,
+    remove,
+};

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

@@ -0,0 +1,47 @@
+import { catchAsync, pick } from '@utils';
+import { tasksService } from '@services';
+import { Response } from "express";
+import { ExtRequest } from '@types';
+
+
+const task_test = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { options } = pick(req.query, ['options']);
+    await tasksService.task_test(String(options), req, res);
+});
+
+const task_handle_old_checks = catchAsync(async (req: ExtRequest, res: Response) => {
+    const options = pick(req.query, ['days', 'remove']);
+    await tasksService.task_handle_old_checks(options, res);
+});
+
+const task_handle_database_consistency = catchAsync(async (req: ExtRequest, res: Response) => {
+    const options = pick(req.query, ['days', 'clean']);
+    await tasksService.task_handle_database_consistency(options, res);
+});
+
+const task_remove_old_logs = catchAsync(async (req: ExtRequest, res: Response) => {
+    const options = pick(req.query, ['days', 'statistics']);
+    await tasksService.task_remove_old_logs(options, res);
+});
+
+const status = catchAsync(async (req: ExtRequest, res: Response) => {
+    res.send(await tasksService.status(req.user));
+});
+
+const screenshots = catchAsync(async (req: ExtRequest, res: Response) => {
+    res.send(await tasksService.screenshots());
+});
+
+const loadTestUser = catchAsync(async (req: ExtRequest, res: Response) => {
+    res.send(await tasksService.loadTestUser());
+});
+
+export {
+    task_test,
+    task_handle_old_checks,
+    task_handle_database_consistency,
+    task_remove_old_logs,
+    status,
+    loadTestUser,
+    screenshots,
+};

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

@@ -0,0 +1,62 @@
+import httpStatus from 'http-status';
+import { pick, ApiError, catchAsync, deserializeIfJSON } from '@utils';
+import { testService } from '@services';
+import { Response } from "express";
+import { ExtRequest } from '@types';
+
+const getTest = catchAsync(async (req: ExtRequest, res: Response) => {
+    const filter = {
+        ...deserializeIfJSON(String(req.query.base_filter)),
+        ...deserializeIfJSON(String(req.query.filter)),
+    };
+
+    if (req.user?.role === 'user') {
+        filter.creatorUsername = req.user?.username;
+    }
+
+    const options = pick(req.query, ['sortBy', 'limit', 'page', 'populate']);
+    const result = await testService.queryTests(filter, options);
+    res.status(httpStatus.OK).send(result);
+});
+
+
+export const distinct_with_filter = catchAsync(async (req: ExtRequest, res: Response) => {
+    const filter = req.query.filter ? deserializeIfJSON(String(req.query.filter)) : undefined;
+    const options = { ...pick(req.query, ['sortBy', 'limit', 'page', 'populate']), field: req.params.field };
+    const result = await testService.queryTestsDistinct( filter , options);
+    res.status(httpStatus.OK).send(result);
+});
+
+// TODO: [Obsolete] use 'distinct_with_filter' instead of this
+const distinct = catchAsync(async (req: ExtRequest, res: Response) => {
+
+    //⚠️ the filter is obsolete there, for filtering use `/v1/test/distict`
+    const filter = {};
+
+    const options = { ...pick(req.query, ['sortBy', 'limit', 'page', 'populate']), field: req.params.id };
+    const result = await testService.queryTestsDistinct( filter , options);
+    res.status(httpStatus.OK).send(result);
+});
+
+const remove = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { id } = req.params;
+    if (!id) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot remove the test - Id not found');
+    if (!req.user) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot remove the test - req.user is empty');
+    const result = await testService.remove(id, req?.user);
+    res.send(result);
+});
+
+const accept = catchAsync(async (req: ExtRequest, res: Response) => {
+    const { id } = req.params;
+    if (!id) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot accept the check - Id not found');
+    if (!req.user) throw new ApiError(httpStatus.BAD_REQUEST, 'Cannot accept the check - req.user is empty');
+    const result = await testService.accept(id, req?.user);
+    res.send(result);
+});
+
+export {
+    getTest,
+    distinct,
+    remove,
+    accept,
+};

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

@@ -0,0 +1,89 @@
+
+import httpStatus from 'http-status';
+import { EJSON } from 'bson';
+import { ApiError, catchAsync, pick } from '@utils';
+import { usersService } from '@services';
+import log from "../lib/logger";
+import { ExtRequest } from '@types';
+import { Response } from "express";
+import { errMsg } from '../utils/errMsg';
+
+const current = catchAsync(async (req: ExtRequest, res: Response) => {
+    const logOpts = {
+        scope: 'users',
+        msgType: 'GET_CURRENT_USER',
+    };
+    log.debug(`current user is: '${req?.user?.username || 'not_logged'}'`, logOpts);
+    res.status(httpStatus.OK).json({
+        id: req?.user?.id,
+        username: req?.user?.username,
+        firstName: req?.user?.firstName,
+        lastName: req?.user?.lastName,
+        role: req?.user?.role,
+    });
+});
+
+const get = catchAsync(async (req: ExtRequest, res: Response) => {
+    const filter = typeof req.query.filter === 'string'
+        ? EJSON.parse(req.query.filter)
+        : {};
+
+    const options = pick(req.query, ['sortBy', 'limit', 'page']);
+    const result = await usersService.queryUsers(filter, options);
+    res.send(result);
+});
+
+
+const getById = catchAsync(async (req: ExtRequest, res: Response) => {
+    const user = await usersService.getUserById(req.params.userId);
+    res.send(user);
+});
+
+const create = catchAsync(async (req: ExtRequest, res: Response) => {
+    const logOpts = {
+        scope: 'users',
+        msgType: 'CREATE',
+    };
+
+    try {
+        const userData = pick(req.body, [
+            'username',
+            'firstName',
+            'lastName',
+            'role',
+            'password',
+            'apiKey',
+            'expiration',
+            'meta',
+        ]);
+        const user = await usersService.createUser(userData);
+        res.status(httpStatus.CREATED).send(user);
+    } catch (e: unknown) {
+        if (e instanceof ApiError && e.statusCode) {
+            log.error(e, logOpts);
+            res.status(e.statusCode).json({ message: e.message });
+        } else {
+            log.error(errMsg(e), logOpts);
+            throw e;
+        }
+    }
+});
+
+const update = catchAsync(async (req: ExtRequest, res: Response) => {
+    const user = await usersService.updateUserById(req.params.userId, req.body);
+    res.send(user);
+});
+
+const remove = catchAsync(async (req: ExtRequest, res: Response) => {
+    await usersService.deleteUserById(req.params.userId);
+    res.status(httpStatus.NO_CONTENT).send();
+});
+
+export {
+    current,
+    create,
+    update,
+    remove,
+    get,
+    getById,
+};

package/src/server/envConfig.ts

@@ -0,0 +1,36 @@
+import { cleanEnv, host, num, port, str, bool } from 'envalid';
+import crypto from 'crypto';
+import path from 'path';
+
+import dotenv from 'dotenv';
+dotenv.config();
+
+export const env = cleanEnv(process.env, {
+  NODE_ENV: str({ choices: ['development', 'production', 'test'] }),
+  SYNGRISI_DB_URI: str({ devDefault: 'mongodb://127.0.0.1:27017/SyngrisiDb' }),
+  SYNGRISI_APP_PORT: port({ devDefault: 3000 }),
+  SYNGRISI_IMAGES_PATH: str({ devDefault: "./.snapshots-images/" }),
+  SYNGRISI_TMP_DIR: str({ default: path.join(process.cwd(), '.tmp') }),
+  SYNGRISI_HTTP_LOG: bool({ devDefault: false }),
+  SYNGRISI_COVERAGE: bool({ devDefault: false }),
+
+  SYNGRISI_HOSTNAME: host({ devDefault: 'localhost' }),
+
+  SYNGRISI_AUTH: bool({ default: true }),
+  SYNGRISI_TEST_MODE: bool({ default: false }),
+  SYNGRISI_DISABLE_FIRST_RUN: bool({ default: false }),
+
+  MONGODB_ROOT_USERNAME: str({ default: '' }),
+  MONGODB_ROOT_PASSWORD: str({ default: '' }),
+  LOGLEVEL: str({ choices: ['error', 'warn', 'info', 'verbose', 'debug', 'silly'], default: 'debug' }),
+  SYNGRISI_PAGINATION_SIZE: num({ default: 50 }),
+  SYNGRISI_DISABLE_DEV_CORS: bool({ default: false, devDefault: true }),
+  SYNGRISI_SESSION_STORE_KEY: str({ default: crypto.randomBytes(64).toString('hex') }),
+  SYNGRISI_LOG_LEVEL: str({ default: 'debug' }),
+
+  // trunk features
+  SYNGRISI_TRUNK_FEATURE_AI_SEVERITY: bool({ default: false }),
+  SYNGRISI_AI_KEY: str({ default: '' }),
+  OPENAI_API_BASE_URL: str({ default: 'https://api.openai.com/v1' }),
+  OPENAI_API_KEY: str({ default: '' }),
+});