@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/schemas/utils/createRequestOpenApiBodySchema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const createRequestOpenApiBodySchema = (schema: z.ZodTypeAny) => ({
+    content: {
+        'application/json': { schema: schema }
+    }
+})

package/src/server/schemas/utils/createRequestParamsSchema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { commonValidations } from './commonValidations';
+export const createRequestParamsSchema = (schema: z.ZodTypeAny) => z.object({ params: schema })
+
+export const getByIdParamsSchema = (id = 'id') => createRequestParamsSchema(
+    z.object({ [id]: commonValidations.id })
+);

package/src/server/schemas/utils/createRequestQuerySchema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const createRequestQuerySchema = (schema: z.ZodTypeAny) => z.object({ query: schema })

package/src/server/schemas/utils/index.ts

@@ -0,0 +1,3 @@
+import { commonValidations } from './commonValidations';
+
+export {commonValidations}

package/src/server/server.ts

@@ -0,0 +1,54 @@
+import 'source-map-support/register';
+import app from './app';
+import v8 from 'v8';
+import { config } from '@config';
+import log from '@logger';
+import chalk from 'chalk';
+import connectDB from '@lib/connectDb';
+import { createTempDir, createBasicUsers, createInitialSettings, createTestsUsers } from '@lib/startup';
+import { errMsg } from './utils';
+
+const logMeta = { scope: 'entrypoint' };
+
+log.info('Connect to database');
+connectDB().then(async () => {
+    log.debug('run init jobs', logMeta);
+    // const startUp = await import('@lib/startup');
+    createTempDir();
+    await createBasicUsers();
+    await createInitialSettings();
+    if (config.testMode) await createTestsUsers();
+
+    const server = app.listen(config.port, () => {
+        log.info(
+            chalk.green(`Syngrisi version: ${chalk.blue((config.version))} started at http://${config.host}:${config.port}`),
+            logMeta
+        );
+        log.info(
+            chalk.whiteBright('Press <Ctrl+C> to exit'), logMeta
+        );
+    });
+
+
+    // exit events
+    const onCloseSignal = () => {
+        log.info('sigint received, shutting down');
+        if (config.codeCoverage) {
+            log.info('take coverage');
+            v8.takeCoverage();
+            v8.stopCoverage();
+        }
+        server.close(() => {
+            log.info('server closed 👋');
+            process.exit();
+        });
+        setTimeout(() => process.exit(1), 10000).unref(); // Force shutdown after 10s
+    };
+
+    process.on('SIGINT', onCloseSignal);
+    process.on('SIGTERM', onCloseSignal);
+}).catch(err => {
+    log.error(`Could not connect to MongoDB: ${errMsg(err)} `);
+    process.exit(1);
+});
+

package/src/server/server_old.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import v8 from 'v8';
+import 'source-map-support/register';
+import express from 'express';
+
+// @ts-ignore
+import cookieParser from 'cookie-parser';
+import MongoStore from 'connect-mongo';
+import chalk from 'chalk';
+
+// @ts-ignore
+import session from 'express-session';
+import mongoose from 'mongoose';
+import bodyParser from 'body-parser';
+// @ts-ignore
+import fileUpload from 'express-fileupload';
+import pino from 'pino';
+import path from 'path';
+// @ts-ignore
+import compression from 'compression';
+import passport from 'passport';
+import PQueue from 'p-queue';
+import crypto from 'crypto';
+
+// @ts-ignore
+import { Strategy as LocalStrategy } from 'passport-local';
+import pinoLogger from 'pino-http';
+
+import { User } from '@models';
+import { config } from '@config';
+
+import { disableCors } from '@middlewares';
+
+import log from '@lib/logger';
+
+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 { vi } from 'vitest';
+
+// @ts-ignore
+global.queue = new PQueue({ concurrency: 1 });
+
+// @ts-ignore
+const logMeta = { scope: 'entrypoint' };
+log.info('Init the application', logMeta);
+
+const coverage = process.env.SYNGRISI_COVERAGE === 'true';
+process.on('SIGINT', () => {
+    if (coverage) {
+        log.info('take coverage');
+        v8.takeCoverage();
+        v8.stopCoverage();
+    }
+    console.log('Program shutting down (Ctrl+C).');
+    process.exit(1);
+});
+
+function compressionFilter(req: express.Request, res: express.Response) {
+    if (req.headers['x-no-compression']) {
+        return false;
+    }
+    return compression.filter(req, res);
+}
+
+const app = express();
+// @ts-ignore
+app.use(compression({ filter: compressionFilter }));
+
+app.use(disableCors);
+
+const storeSessionKey = process.env.SYNGRISI_SESSION_STORE_KEY || crypto.randomBytes(64).toString('hex');
+
+const expressSession = session({
+    secret: storeSessionKey,
+    resave: true,
+    saveUninitialized: false,
+    cookie: { secure: false },
+    store: MongoStore.create({ mongoUrl: config.connectionString }),
+});
+
+// @ts-ignore
+app.use(expressSession);
+
+log.info('Init passport', logMeta);
+app.use(passport.initialize());
+app.use(passport.session());
+passport.use(new LocalStrategy({}, User.authenticate()));
+// @ts-ignore
+passport.serializeUser(User.serializeUser());
+passport.deserializeUser(User.deserializeUser());
+
+app.use(bodyParser.json());
+app.use(bodyParser.urlencoded({ extended: true }));
+
+if (config.enableHttpLogger === 'true') {
+    app.use(
+        pinoLogger(
+            {
+                name: 'vrs',
+                autoLogging: true,
+                useLevel: 'info',
+            },
+            pino.destination(config.httpLoggerFilePath)
+        )
+    );
+}
+
+// @ts-ignore
+app.use(cookieParser());
+
+// @ts-ignore
+app.use(
+    // @ts-ignore
+    fileUpload({ limits: { fileSize: 50 * 1024 * 1024 }, })
+);
+
+
+log.info('Init static middlewares', logMeta);
+const baseDir = process.cwd();
+const viewPath = path.join(baseDir, './mvc/views/');
+
+app.set('views', viewPath);
+
+app.set('view engine', 'ejs');
+
+app.use(express.json({ limit: '50mb' }));
+
+const screenshotsPath = path.join(baseDir, config.defaultImagesPath);
+
+app.use('/snapshoots', express.static(screenshotsPath));
+const staticPath = path.join(baseDir, './src/server/static/static');
+
+app.use('../static', express.static(staticPath));
+const assetsPath = path.join(baseDir, './mvc/views/react/assets');
+app.use('/assets', express.static(assetsPath));
+
+
+log.info('Init routes', logMeta);
+
+app.use('/v1', routes);
+app.use('/auth', authRoutes);
+app.use('/admin*', adminRoutes);
+app.use('/', uiRoutes);
+
+app.use((req, res) => {
+    res.status(404).json({ url: `${req.originalUrl} not found` });
+});
+
+log.info('Connect to database');
+
+mongoose.Promise = global.Promise;
+
+// // eslint-disable-next-line @typescript-eslint/no-unused-vars
+// let server: any;
+mongoose.set('strictQuery', false);
+mongoose
+    // .connect(config.connectionString, { useUnifiedTopology: true })
+    .connect(config.connectionString)
+    .then(async () => {
+        log.info('Connected to MongoDB');
+        log.info('Load application setting', logMeta);
+        log.debug('run onStart jobs', logMeta);
+        const startUp = await import('@lib/startup');
+        startUp.createTempDir();
+        await startUp.createBasicUsers();
+        await startUp.createInitialSettings();
+        if (process.env.SYNGRISI_TEST_MODE === '1') await startUp.createTestsUsers();
+
+        log.info('Get Application version', logMeta);
+
+        log.info('Load devices list', logMeta);
+
+        app.listen(config.port, () => {
+            log.info(
+                chalk.green(`Syngrisi version: ${chalk.blue((config.version))} started at http://localhost:${config.port}`),
+                logMeta
+            );
+            log.info(chalk.whiteBright('Press <Ctrl+C> to exit'), logMeta);
+        });
+
+    });

package/src/server/services/app.service.ts

@@ -0,0 +1,9 @@
+import { App } from '@models';
+import { FilterQuery } from 'mongoose';
+import { PaginateOptions } from '@models/plugins/utils';
+
+const get = async (filter:  FilterQuery<typeof App> , options: PaginateOptions) => App.paginate(filter, options);
+
+export {
+    get,
+};

package/src/server/services/auth.service.ts

@@ -0,0 +1,94 @@
+import hasha from 'hasha';
+import uuidAPIKey from 'uuid-apikey';
+import { User } from '@models';
+import log from "../lib/logger";
+import { RequestUser } from '@types';
+import { ApiError, errMsg } from '@utils';
+import { appSettings } from "@settings";
+import httpStatus from 'http-status';
+
+function getApiKey(): string {
+    return uuidAPIKey.create().apiKey;
+}
+
+const generateApiKey = async (username: string): Promise<string> => {
+    const logOpts = {
+        user: username,
+        scope: 'apikey',
+        msgType: 'GENERATE_API'
+    };
+
+    const apiKey = getApiKey();
+    log.debug(
+        `generate API Key for user: '${username}'`,
+        logOpts
+    );
+    const hash = hasha(apiKey);
+
+    const user: RequestUser | null = await User.findOne({ username });
+    if (!user) throw new Error(`cannot find the user with username: '${username}'`);
+
+    user.apiKey = hash;
+    await user.save();
+    return apiKey;
+};
+
+const changeUserPassword = async (username: string, currentPassword: string, newPassword: string): Promise<void> => {
+    const logOpts = {
+        scope: 'changePassword',
+        msgType: 'CHANGE_PASSWORD',
+        itemType: 'user',
+        ref: username,
+    };
+
+    log.debug(`change password for '${username}', params: '${JSON.stringify({ currentPassword, newPassword })}'`, logOpts);
+
+    const user: RequestUser | null = await User.findOne({ username });
+    if (!user) {
+        log.error('user is not logged in', logOpts);
+        throw new Error('user is not logged in');
+    }
+
+    try {
+        await user.changePassword(currentPassword, newPassword);
+    } catch (e: unknown) {
+        log.error(e, logOpts);
+        throw new Error(errMsg(e));
+    }
+
+    log.debug(`password was successfully changed for user: ${username}`, logOpts);
+};
+
+const changePasswordFirstRun = async (newPassword: string): Promise<void> => {
+    const logOpts = {
+        scope: 'changePasswordFirstRun',
+        msgType: 'CHANGE_PASSWORD_FIRST_RUN',
+        itemType: 'user',
+        ref: 'Administrator',
+    };
+
+    const AppSettings = await appSettings;
+
+    if ((await AppSettings.isAuthEnabled()) && ((await AppSettings.isFirstRun()))) {
+        log.debug(`first run, change password for default 'Administrator', params: '${JSON.stringify({ newPassword })}'`, logOpts);
+        const user = await User.findOne({ username: 'Administrator' }).exec();
+
+        if (!user) throw new ApiError(httpStatus.NOT_FOUND, `cannot change password at first run, user withusername: 'Administrator', not found`);
+
+        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);
+    } else {
+        log.error(`trying to use first run API with no first run state, auth: '${await AppSettings.isAuthEnabled()}', global settings: '${(await AppSettings.get('first_run'))}'`, logOpts);
+        throw new Error('forbidden');
+    }
+};
+
+export {
+    generateApiKey,
+    changeUserPassword,
+    changePasswordFirstRun,
+};

package/src/server/services/check.service.ts

@@ -0,0 +1,241 @@
+import {
+    Check,
+    Test,
+    Suite,
+    Baseline,
+    CheckDocument,
+} from '@models';
+
+import { calculateAcceptedStatus, buildIdentObject } from '@utils';
+import * as snapshotService from './snapshot.service';
+import * as orm from '@lib/dbItems';
+import log from '@lib/logger';
+import { BaselineDocument } from '@models/Baseline.model';
+import { Schema } from 'mongoose';
+import { LogOpts, RequestUser } from '@root/src/types';
+
+async function calculateTestStatus(testId: string): Promise<string> {
+    const checksInTest = await Check.find({ test: testId });
+    const statuses = checksInTest.map((x: CheckDocument) => x.status[0]);
+    let testCalculatedStatus = 'Failed';
+    if (statuses.every((x: string) => (x === 'new') || (x === 'passed'))) {
+        testCalculatedStatus = 'Passed';
+    }
+    if (statuses.every((x: string) => (x === 'new'))) {
+        testCalculatedStatus = 'New';
+    }
+    return testCalculatedStatus;
+}
+
+
+export interface baselineParamsType extends Document {
+    snapshootId?: string;
+    name: string;
+    app: string;
+    branch: string;
+    browserName: string;
+    browserVersion?: string;
+    browserFullVersion?: string;
+    viewport: string;
+    os: string;
+    markedAs?: 'bug' | 'accepted';
+    lastMarkedDate?: Date;
+    createdDate?: Date;
+    updatedDate?: Date;
+    markedById?: Schema.Types.ObjectId;
+    markedByUsername?: string;
+    ignoreRegions?: string;
+    boundRegions?: string;
+    matchType?: 'antialiasing' | 'nothing' | 'colors';
+    meta?: object;
+    actualSnapshotId: Schema.Types.ObjectId;
+    markedDate: Date;
+}
+
+
+const validateBaselineParam = (params: baselineParamsType): void => {
+    const mandatoryParams = ['markedAs', 'markedById', 'markedByUsername', 'markedDate'];
+    for (const param of mandatoryParams) {
+        if (!params[param as keyof baselineParamsType]) {
+            const errMsg = `invalid baseline parameters, '${param}' is empty, params: ${JSON.stringify(params)}`;
+            log.error(errMsg);
+            throw new Error(errMsg);
+        }
+    }
+};
+
+async function createNewBaseline(params: baselineParamsType): Promise<BaselineDocument> {
+    const logOpts = {
+        scope: 'createNewBaseline',
+        msgType: 'CREATE',
+    };
+
+
+    validateBaselineParam(params);
+
+    const identFields = buildIdentObject(params);
+
+    const lastBaseline = await Baseline.findOne(identFields).exec();
+    const sameBaseline = await Baseline.findOne({ ...identFields, snapshootId: params.actualSnapshotId }).exec();
+
+    const baselineParams = lastBaseline?.ignoreRegions
+        ? { ...identFields, ignoreRegions: lastBaseline.ignoreRegions }
+        : identFields;
+
+    if (sameBaseline) {
+        log.debug(`the baseline with same ident and snapshot id: ${params.actualSnapshotId} already exist`, logOpts);
+    } else {
+        log.debug(`the baseline with same ident and snapshot id: ${params.actualSnapshotId} does not exist,
+         create new one, baselineParams: ${JSON.stringify(baselineParams)}`, logOpts);
+    }
+
+    log.silly({ sameBaseline });
+
+    const resultedBaseline: BaselineDocument = sameBaseline || await Baseline.create(baselineParams);
+
+    resultedBaseline.markedAs = params.markedAs;
+    resultedBaseline.markedById = params.markedById //? new Schema.Types.ObjectId(String(params.markedById)) : undefined;
+    resultedBaseline.markedByUsername = params.markedByUsername;
+    resultedBaseline.lastMarkedDate = params.markedDate;
+    resultedBaseline.createdDate = new Date();
+    resultedBaseline.snapshootId = params.actualSnapshotId //? new Schema.Types.ObjectId(String(params.actualSnapshotId)) : undefined;
+
+    return resultedBaseline.save();
+}
+
+const accept = async (id: string, baselineId: string, user: RequestUser): Promise<CheckDocument> => {
+    const logOpts = {
+        msgType: 'ACCEPT',
+        itemType: 'check',
+        ref: id,
+        user: user?.username,
+        scope: 'accept',
+    };
+    log.debug(`accept check: ${id}`, logOpts);
+    const check = await Check.findById(id).exec();
+    if (!check) throw new Error(`cannot find check with id: ${id}`);
+    const test = await Test.findById(check.test).exec();
+    if (!test) throw new Error(`cannot find test with id: ${check.test}`);
+    check.markedById = user._id;
+    check.markedByUsername = user.username;
+    check.markedDate = new Date();
+    check.markedAs = 'accepted';
+    check.status = (check.status[0] === 'new') ? ['new'] : ['passed'];
+    check.updatedDate = new Date();
+
+    // TODO: remove this line
+    check.baselineId = baselineId as unknown as Schema.Types.ObjectId;
+
+    log.debug(`update check with options: '${JSON.stringify(check.toObject())}'`, logOpts);
+    await createNewBaseline(check.toObject());
+    await check.save();
+
+    const testCalculatedStatus = await calculateTestStatus(String(check.test));
+    const testCalculatedAcceptedStatus = await calculateAcceptedStatus(check.test);
+
+    test.status = testCalculatedStatus;
+    test.markedAs = testCalculatedAcceptedStatus;
+    test.updatedDate = new Date();
+
+    await Suite.findByIdAndUpdate(check.suite, { updatedDate: Date.now() });
+    log.debug(`update test with status: '${testCalculatedStatus}', marked: '${testCalculatedAcceptedStatus}'`, logOpts, {
+        msgType: 'UPDATE',
+        itemType: 'test',
+        ref: test._id,
+    });
+    await test.save();
+    await check.save();
+    log.debug(`check with id: '${id}' was updated`, logOpts);
+    return check;
+};
+
+async function removeCheck(id: string, user: RequestUser): Promise<CheckDocument> {
+    const logMeta = {
+        scope: 'removeCheck',
+        itemType: 'check',
+        ref: id,
+        msgType: 'REMOVE',
+        user: user?.username,
+    };
+
+    try {
+        const check = (await Check.findByIdAndDelete(id).exec()) as unknown as CheckDocument;
+        if (!check) throw new Error(`cannot find check with id: ${id}`);
+
+        log.debug(`check with id: '${id}' was removed, update test: ${check.test}`, logMeta);
+
+        const test = await Test.findById(check.test).exec();
+        if (!test) throw new Error(`cannot find test with id: ${check.test}`);
+
+        const testCalculatedStatus = await calculateTestStatus(String(check.test));
+        const testCalculatedAcceptedStatus = await calculateAcceptedStatus(check.test);
+        test.status = testCalculatedStatus;
+        test.markedAs = testCalculatedAcceptedStatus;
+        test.updatedDate = new Date();
+        await orm.updateItemDate('VRSSuite', check.suite);
+        await test.save();
+
+        if (check.baselineId && String(check.baselineId) !== 'undefined') {
+            log.debug(`try to remove the snapshot, baseline: ${check.baselineId}`, logMeta);
+            await snapshotService.remove(check.baselineId.toString());
+        }
+
+        if (check.actualSnapshotId && String(check.baselineId) !== 'undefined') {
+            log.debug(`try to remove the snapshot, actual: ${check.actualSnapshotId}`, logMeta);
+            await snapshotService.remove(check.actualSnapshotId.toString());
+        }
+
+        if (check.diffId && String(check.baselineId) !== 'undefined') {
+            log.debug(`try to remove snapshot, diff: ${check.diffId}`, logMeta);
+            await snapshotService.remove(check.diffId.toString());
+        }
+        return check;
+    } catch (e: unknown) {
+        const errMsg = `cannot remove a check with id: '${id}', error: '${e instanceof Error ? e.stack : String(e)}'`;
+        log.error(errMsg, logMeta);
+        throw new Error(errMsg);
+    }
+}
+
+const remove = async (id: string, user: RequestUser): Promise<CheckDocument> => {
+    const logOpts = {
+        scope: 'removeCheck',
+        itemType: 'check',
+        ref: id,
+        user: user?.username,
+        msgType: 'REMOVE',
+    };
+    log.info(`remove check with, id: '${id}', user: '${user.username}'`, logOpts);
+    return removeCheck(id, user);
+};
+
+const update = async (id: string, opts: Partial<CheckDocument>, user: string): Promise<CheckDocument> => {
+    const logMeta: LogOpts = {
+        msgType: 'UPDATE',
+        itemType: 'check',
+        ref: id,
+        user,
+        scope: 'updateCheck',
+    };
+    log.debug(`update check with id '${id}' with params '${JSON.stringify(opts, null, 2)}'`, logMeta);
+
+    const check = await Check.findOneAndUpdate({ _id: id }, opts, { new: true }).exec();
+    if (!check) throw new Error(`cannot find check with id: ${id}`);
+
+    const test = await Test.findOne({ _id: check.test }).exec();
+    if (!test) throw new Error(`cannot find test with id: ${check.test}`);
+
+    test.status = await calculateTestStatus(String(check.test));
+
+    await orm.updateItemDate('VRSCheck', check);
+    await orm.updateItemDate('VRSTest', test);
+    await test.save();
+    await check.save();
+    return check;
+};
+
+export {
+    accept,
+    remove,
+    update,
+};