@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/lib/AppSettings/AppSettings.ts

@@ -0,0 +1,88 @@
+/* eslint-disable dot-notation */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { AppSettings as AppSettingsModel } from '@models';
+import initialAppSettings from '../../../seeds/initialAppSettings.json';
+import { env } from "@/server/envConfig";
+
+class AppSettings {
+    private model: any;
+    public cache: any;
+
+    constructor() {
+        this.model = AppSettingsModel;
+        this.cache = null; // Initialize cache as null to indicate uninitialized state
+    }
+
+    async init() {
+        this.cache = await this.model.find().lean().exec();
+        return this;
+    }
+
+    private ensureInitialized() {
+        if (!this.cache) {
+            throw new Error('AppSettings is not initialized. Please call init() before using this method.');
+        }
+    }
+
+    async count(): Promise<number> {
+        this.ensureInitialized();
+        return this.model.countDocuments().exec();
+    }
+
+    async loadInitialFromFile(): Promise<void> {
+        this.ensureInitialized();
+        const settings = initialAppSettings;
+        await this.model.insertMany(settings);
+        this.cache = settings;
+    }
+
+    async get(name: string): Promise<any> {
+        this.ensureInitialized();
+        return this.cache.find((x: any) => x.name === name)
+            || (this.model.findOne({ name }).exec());
+    }
+
+    async set(name: string, value: any): Promise<void> {
+        this.ensureInitialized();
+        const item = await this.model.findOneAndUpdate({ name }, { value });
+        await item.save();
+        const cachedItem = this.cache.find((x: any) => x.name === name);
+        if (cachedItem) {
+            cachedItem['value'] = value;
+        }
+    }
+
+    async enable(name: string): Promise<void> {
+        this.ensureInitialized();
+        const item = await this.model.findOneAndUpdate({ name }, { enabled: true });
+        await item.save();
+        const cachedItem = this.cache.find((x: any) => x.name === name);
+        if (cachedItem) {
+            cachedItem['enabled'] = true;
+        }
+    }
+
+    async disable(name: string): Promise<void> {
+        this.ensureInitialized();
+        const item = await this.model.findOneAndUpdate({ name }, { enabled: false });
+        await item.save();
+        const cachedItem = this.cache.find((x: any) => x.name === name);
+        if (cachedItem) {
+            cachedItem['enabled'] = false;
+        }
+    }
+
+    async isAuthEnabled(): Promise<boolean> {
+        this.ensureInitialized();
+        return env.SYNGRISI_AUTH  || (await this.get('authentication'))?.value === 'true';
+    }
+
+    async isFirstRun(): Promise<boolean> {
+        this.ensureInitialized();
+        return (await this.get('first_run'))?.value === 'true';
+    }
+}
+
+const appSettings = (new AppSettings()).init();
+export { AppSettings, appSettings };

package/src/server/lib/AppSettings/index.ts

@@ -0,0 +1 @@
+export { AppSettings, appSettings } from './AppSettings';

package/src/server/lib/connectDb.ts

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+import { config } from '@config';
+import log from '@logger';
+import { errMsg } from '../utils/errMsg';
+
+mongoose.Promise = global.Promise;
+mongoose.set('strictQuery', false);
+
+const connectDB = async () => {
+    try {
+        await mongoose.connect(config.connectionString);
+    } catch (error: unknown) {
+        log.error(`Could not connect to MongoDB: ${errMsg(error)}`);
+        process.exit(1);
+    }
+};
+
+export default connectDB;

package/src/server/lib/dbItems/createAppIfNotExist.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { App } from '@models';
+import log from "@logger";
+
+export async function createAppIfNotExist(params: any): Promise<any> {
+    const logOpts = {
+        scope: 'createAppIfNotExist',
+        msgType: 'CREATE',
+        itemType: 'VRSApp',
+    };
+    if (!params.name) return {};
+
+    log.debug(`try to create app if exist, params: '${JSON.stringify(params)}'`, logOpts);
+
+    let app = await App.findOne({ name: params.name }).exec();
+
+    if (app) {
+        log.debug(`app already exist: '${JSON.stringify(params)}'`, logOpts);
+        return app;
+    }
+
+    app = await App.create(params);
+    log.debug(`app with name: '${params.name}' was created`, logOpts);
+    return app;
+}

package/src/server/lib/dbItems/createItemIfNotExist.ts

@@ -0,0 +1,29 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import mongoose from 'mongoose';
+import log from "@logger";
+
+export async function createItemIfNotExist(modelName: string, params: any, logsMeta = {}): Promise<any> {
+    const logOpts = {
+        scope: 'createItemIfNotExist',
+        msgType: 'CREATE',
+        itemType: modelName,
+    };
+    try {
+        const itemModel = mongoose.model(modelName);
+        const options = {
+            upsert: true,
+            new: true,
+            setDefaultsOnInsert: true,
+        };
+
+        await itemModel.init();
+        const item = await itemModel.findOneAndUpdate(params, params, options);
+
+        log.info(`ORM item '${modelName}' was created: '${JSON.stringify(item)}'`, { ...logOpts, ...{ ref: String(item?._id) }, ...logsMeta });
+        return item;
+    } catch (e: any) {
+        log.debug(`cannot create '${modelName}' ORM item, error: '${e.stack || e}'`, { ...logOpts, ...logsMeta });
+    }
+    return null;
+}

package/src/server/lib/dbItems/createItemProm.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import mongoose from 'mongoose';
+import log from "@logger";
+
+const logOpts = {
+    scope: 'dbitems',
+    msgType: 'DB',
+};
+
+export async function createItemProm(modelName: string, params: any): Promise<any> {
+    try {
+        const itemModel = mongoose.model(modelName);
+        log.debug(`start to create ORM item via promise: '${modelName}', params: '${JSON.stringify(params)}'`, logOpts);
+        const item = await itemModel.create(params);
+        return item;
+    } catch (e: any) {
+        const errMsg = `cannot create '${modelName}', error: '${e.stack || e}'`;
+        log.error(errMsg, logOpts);
+        throw new Error(errMsg);
+    }
+}

package/src/server/lib/dbItems/createRunIfNotExist.ts

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Run } from '@models';
+import { errMsg } from '@utils';
+import log from "@logger";
+
+export async function createRunIfNotExist(params: any, logsMeta = {}): Promise<any> {
+    const logOpts = {
+        scope: 'createRunIfNotExist',
+        msgType: 'CREATE',
+        itemType: 'VRSRun',
+    };
+    let run;
+    try {
+        if (!params.name || !params.app || !params.ident) {
+            throw new Error(`Cannot create run, wrong params: '${JSON.stringify(params)}'`);
+        }
+
+        log.debug(`try to create run if exist, params: '${JSON.stringify(params)}'`, { ...logOpts, ...logsMeta });
+
+        run = await Run.findOne({ ident: params.ident }).exec();
+
+        if (run) {
+            log.debug(`run already exist: '${JSON.stringify(params)}'`, { ...logOpts, ...logsMeta });
+            return run;
+        }
+
+        run = await Run.create({
+            ...params,
+            createdDate: params.createdDate || new Date(),
+        });
+
+        log.debug(`run with name: '${params.name}' was created: ${run}`, { ...logOpts, ...logsMeta });
+        return run;
+    } catch (e: any) {
+        if (e.code === 11000) {
+            log.warn(`run key duplication collision: '${JSON.stringify(params)}', error: '${errMsg(e)}'`, { ...logOpts, ...logsMeta });
+            run = await Run.findOne({ name: params.name, ident: params.ident });
+            log.warn(`run key duplication collision, found: '${JSON.stringify(run)}'`, { ...logOpts, ...logsMeta });
+            if (run) return run;
+        }
+        log.error(`cannot create run, params: '${JSON.stringify(params)}', error: '${errMsg(e)}', obj: ${JSON.stringify(e)}`, { ...logOpts, ...logsMeta });
+        throw e;
+    }
+}

package/src/server/lib/dbItems/createSuiteIfNotExist.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Suite } from '@models';
+import log from "@logger";
+
+export async function createSuiteIfNotExist(params: any, logsMeta = {}): Promise<any> {
+    const logOpts = {
+        scope: 'createSuiteIfNotExist',
+        msgType: 'CREATE',
+        itemType: 'VRSSuite',
+    };
+    if (!params.name || !params.app) throw new Error(`Cannot create suite, wrong params: '${JSON.stringify(params)}'`);
+
+    log.debug(`try to create suite if exist, params: '${JSON.stringify(params)}'`,  { ...logOpts, ...logsMeta });
+
+    let suite = await Suite.findOne({ name: params.name }).exec();
+
+    if (suite) {
+        log.debug(`suite already exist: '${JSON.stringify(params)}'`,  { ...logOpts, ...logsMeta });
+        return suite;
+    }
+
+    suite = await Suite.create(params);
+
+    log.debug(`suite with name: '${params.name}' was created`,  { ...logOpts, ...logsMeta });
+    return suite;
+}

package/src/server/lib/dbItems/createTest.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { createItemProm } from './createItemProm';
+
+export async function createTest(params: any): Promise<any> {
+    return createItemProm('VRSTest', params);
+}

package/src/server/lib/dbItems/createUser.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { createItemProm } from './createItemProm';
+
+export async function createUser(params: any): Promise<any> {
+    return createItemProm('VRSUser', params).catch((e) => Promise.reject(e));
+}

package/src/server/lib/dbItems/index.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export { updateItem } from './updateItem';
+export { updateItemDate } from './updateItemDate';
+export { createItemIfNotExist } from './createItemIfNotExist';
+export { createItemIfNotExist as createItemIfNotExistAsync } from './createItemIfNotExist';
+export { createItemProm } from './createItemProm';
+export { createTest } from './createTest';
+export { createUser } from './createUser';
+export { createAppIfNotExist } from './createAppIfNotExist';
+export { createSuiteIfNotExist } from './createSuiteIfNotExist';
+export { createRunIfNotExist } from './createRunIfNotExist';

package/src/server/lib/dbItems/updateItem.ts

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import mongoose from 'mongoose';
+import log from "@logger";
+
+
+export async function updateItem(itemType: string, filter: any, params: any): Promise<any> {
+    const logOpts = {
+        scope: 'updateItem',
+        msgType: 'UPDATE',
+        itemType,
+    };
+    log.debug(`update item type: '${itemType}', filter: '${JSON.stringify(filter)}', params: '${JSON.stringify(params)}'`, logOpts);
+    const itemModel = await mongoose.model(itemType).findOne(filter);
+    const updatedItem = await itemModel?.updateOne(params);
+    log.debug(`'${itemType}' was updated: '${JSON.stringify(updatedItem)}'`, { ...logOpts, ...{ ref: String(itemModel?._id) } });
+    return updatedItem;
+}

package/src/server/lib/dbItems/updateItemDate.ts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import mongoose from 'mongoose';
+import log from "@logger";
+
+
+const logOpts = {
+    scope: 'dbitems',
+    msgType: 'DB',
+};
+
+export async function updateItemDate(mdClass: string, id: any): Promise<any> {
+    log.debug(`update date for the item: '${mdClass}' with id: '${id}'`, logOpts);
+    const itemModel = await mongoose.model(mdClass).findById(id);
+    const updatedItem = await itemModel?.updateOne({ updatedDate: Date.now() });
+    log.debug(`'${mdClass}' date updated: '${JSON.stringify(itemModel)}'`, logOpts);
+    return updatedItem;
+}

package/src/server/lib/httpLogger.ts

@@ -0,0 +1,14 @@
+import pinoLogger from 'pino-http';
+import {config} from '@config';
+import pino from 'pino';
+
+const httpLogger = pinoLogger(
+    {
+        name: 'vrs',
+        autoLogging: true,
+        useLevel: 'info',
+    },
+    pino.destination(config.httpLoggerFilePath)
+);
+
+export default httpLogger;

package/src/server/lib/logger.ts

@@ -0,0 +1,147 @@
+import winston, { Logger as WinstonLogger } from 'winston';
+import 'winston-mongodb';
+import { blue, gray, magenta } from 'chalk';
+import formatISOToDateTime from '@utils/formatISOToDateTime';
+import { config } from '@config';
+import path from 'path';
+import { LogOpts } from '@types';
+import { ApiError } from '../utils';
+import { env } from "@env";
+
+const logLevel: string = env.SYNGRISI_LOG_LEVEL;
+
+interface LoggerOptions {
+    dbConnectionString: string;
+}
+function getScriptLine(): string {
+    const stack = new Error().stack;
+
+    if (stack) {
+        const stackLines = stack.split('\n');
+        let loggerLineIndex = -1;
+
+        // last string contains 'lib/logger'
+        for (let i = 0; i < stackLines.length; i++) {
+            if (stackLines[i].includes('lib/logger')) {
+                loggerLineIndex = i;
+            }
+        }
+
+        // check string after 'lib/logger'
+        const targetLineIndex = loggerLineIndex + 1;
+        if (targetLineIndex >= 0 && targetLineIndex < stackLines.length) {
+            const targetLine = stackLines[targetLineIndex];
+            const match = targetLine.match(/at\s+(?:.+\s+\()?(.+):(\d+):(\d+)\)?/);
+            if (match) {
+                const scriptPath = match[1];
+                const relativePath = path.relative(process.cwd(), scriptPath);
+                const lineNumber = match[2];
+                return `${relativePath}:${lineNumber}`;
+            }
+        }
+    }
+    return 'unknown';
+}
+
+function createWinstonLogger(opts: LoggerOptions): WinstonLogger {
+    return winston.createLogger({
+        transports: [
+            new winston.transports.Console({
+                level: logLevel || 'silly',
+                format: winston.format.combine(
+                    winston.format.colorize(),
+                    winston.format.timestamp(),
+                    winston.format.ms(),
+                    winston.format.metadata(),
+                    winston.format.printf((info) => {
+                        const user = info.metadata.user ? blue(` <${info.metadata.user}>`) : '';
+                        const ref = info.metadata.ref ? gray(` ${info.metadata.ref}`) : '';
+                        const msgType = info.metadata.msgType ? ` ${info.metadata.msgType}` : '';
+                        const itemType = info.metadata.itemType ? magenta(` ${info.metadata.itemType}`) : '';
+                        const scope = info.metadata.scope ? magenta(` [${info.metadata.scope}] `) : magenta(` [${getScriptLine()}] `);
+                        const msg = typeof info.message === 'object'
+                            ? `\n${JSON.stringify(info.message, null, 2)}`
+                            : info.message;
+
+                        return `${info.level} ${scope}${formatISOToDateTime(info.metadata.timestamp)} `
+                            + `${info.metadata.ms}${user}${ref}${msgType}${itemType} '${msg}'`;
+                    }),
+                    winston.format.padLevels(),
+                ),
+            }),
+            new winston.transports.MongoDB({
+                level: logLevel || 'debug',
+                format: winston.format.combine(
+                    winston.format.timestamp(),
+                    winston.format.json(),
+                    winston.format.metadata(),
+                ),
+                options: {
+                    useUnifiedTopology: true,
+                },
+                db: opts.dbConnectionString,
+                collection: 'vrslogs',
+            }),
+        ],
+    });
+}
+
+class Logger {
+    private winstonLogger: WinstonLogger;
+
+    constructor(opts: LoggerOptions = { dbConnectionString: config.connectionString }) {
+        this.winstonLogger = createWinstonLogger(opts);
+    }
+
+    private static mergeMeta(objects: LogOpts[]): LogOpts {
+        return objects.reduce((acc, obj) => {
+            return { ...acc, ...obj };
+        }, {});
+    }
+
+    private log(severity: string, msg: string | object, meta: LogOpts[]): void {
+        const mergedMeta = Logger.mergeMeta(meta);
+        if (!mergedMeta.scope) {
+            mergedMeta.scope = getScriptLine();
+        }
+        const formattedMsg = typeof msg === 'object' ? JSON.stringify(msg, null, 2) : msg;
+        this.winstonLogger.log(severity, formattedMsg, mergedMeta);
+    }
+
+    public error(msg: string | object | unknown, ...meta: LogOpts[]): void {
+        let message: unknown = String(msg);
+        let code = 0;
+        if ((msg instanceof Object)) {
+            message = JSON.stringify(msg);
+        }
+        if ((msg instanceof Error)) {
+            message = msg.stack;
+        }
+        if ((msg instanceof ApiError)) {
+            code = msg.statusCode;
+        }
+        this.log('error', `${code !== 0 ? '[' + code + ']' : ''}${message}\n stacktrace: ${new Error().stack}`, meta);
+    }
+
+    public warn(msg: string | object, ...meta: LogOpts[]): void {
+        this.log('warn', `${msg}\n stacktrace: ${new Error().stack}`, meta);
+    }
+
+    public info(msg: string | object, ...meta: LogOpts[]): void {
+        this.log('info', msg, meta);
+    }
+
+    public verbose(msg: string | object, ...meta: LogOpts[]): void {
+        this.log('verbose', msg, meta);
+    }
+
+    public debug(msg: string | object, ...meta: LogOpts[]): void {
+        this.log('debug', msg, meta);
+    }
+
+    public silly(msg: string | object, ...meta: LogOpts[]): void {
+        this.log('silly', msg, meta);
+    }
+}
+
+export default new Logger();

package/src/server/lib/startup/createBasicUsers.ts

@@ -0,0 +1,25 @@
+/* eslint-disable no-underscore-dangle */
+import { User } from '@models';
+import adminData from '../../../seeds/admin.json';
+import guestData from '../../../seeds/guest.json';
+import log from "@logger";
+
+const logOpts = {
+    scope: 'on_start',
+    msgType: 'SETUP',
+};
+
+export async function createBasicUsers(): Promise<void> {
+    const defAdmin = await User.findOne({ username: 'Administrator' }).exec();
+    const defGuest = await User.findOne({ username: 'Guest' }).exec();
+    if (!defAdmin) {
+        log.info('create the default Administrator', logOpts);
+        const admin = await User.create(adminData);
+        log.info(`administrator with id: '${admin._id}' was created`, logOpts);
+    }
+    if (!defGuest) {
+        log.info('create the default Guest', logOpts);
+        const guest = await User.create(guestData);
+        log.info(`guest with id: '${guest._id}' was created`, logOpts);
+    }
+}

package/src/server/lib/startup/createInitialSettings.ts

@@ -0,0 +1,8 @@
+import { appSettings } from "@settings";
+
+export async function createInitialSettings(): Promise<void> {
+    const settings = await appSettings;
+    if (await settings.count() < 1) {
+        await settings.loadInitialFromFile();
+    }
+}

package/src/server/lib/startup/createTempDir.ts

@@ -0,0 +1,9 @@
+import fs from 'fs';
+import { config } from '@config'
+
+export function createTempDir(): void {
+    const dir = config.tmpDir;
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+    }
+}

package/src/server/lib/startup/createTestsUsers.ts

@@ -0,0 +1,17 @@
+import { User } from '@models';
+import testUsers from '../../../seeds/testUsers.json';
+import log from "@logger";
+
+const logOpts = {
+    scope: 'on_start',
+    msgType: 'SETUP',
+};
+
+export async function createTestsUsers(): Promise<void> {
+    log.debug('creating tests users', logOpts);
+    try {
+        await User.insertMany(testUsers);
+    } catch (e) {
+        console.warn(e);
+    }
+}

package/src/server/lib/startup/index.ts

@@ -0,0 +1,4 @@
+export { createTempDir } from './createTempDir';
+export { createInitialSettings } from './createInitialSettings';
+export { createBasicUsers } from './createBasicUsers';
+export { createTestsUsers } from './createTestsUsers';

package/src/server/lib//321/201omparison/comparator.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { errMsg } from "@utils";
+import log from "@logger";
+import compareImages from './compareImagesNode';
+
+const DEFAULT_OPTIONS = {
+    output: {
+        largeImageThreshold: 0,
+        outputDiff: true,
+        errorType: 'flat',
+        transparency: 0,
+    },
+    ignore: 'nothing',
+};
+
+async function makeDiff(imgData1: any, imgData2: any, options: any = {}): Promise<any> {
+    const opts = Object.assign(DEFAULT_OPTIONS, options);
+    opts.ignoreRectangles = options.ignoredBoxes;
+    const compareData = await compareImages(imgData1, imgData2, opts);
+    return compareData;
+}
+
+async function getDiff(baselineOrigin: any, actualOrigin: any, opts: any = {}): Promise<any> {
+    const logOpts = {
+        scope: 'getDiff',
+        itemType: 'image',
+        msgType: 'GET_DIFF',
+    };
+    try {
+        const executionTimer = process.hrtime();
+
+        log.debug(`SAMPLE #1: ${process.hrtime(executionTimer).toString()}`, logOpts);
+
+        const directDiff = await makeDiff(baselineOrigin, actualOrigin, opts);
+        log.debug(`SAMPLE #2: ${process.hrtime(executionTimer).toString()}`, logOpts);
+
+        directDiff.executionTotalTime = process.hrtime(executionTimer).toString();
+
+        log.debug(`SAMPLE #3: ${process.hrtime(executionTimer).toString()}`, logOpts);
+        log.debug(`the diff is: ${JSON.stringify(directDiff, null, 4)}`, logOpts);
+
+        return directDiff;
+    } catch (e: unknown) {
+        log.error(errMsg(e), logOpts);
+        throw new Error(errMsg(e));
+    }
+}
+
+export { getDiff };

package/src/server/lib//321/201omparison/compareImagesNode.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// @ts-ignore
+import resemble from '@syngrisi/node-resemble.js';
+
+async function streamToBuffer(stream: any): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+        const data: Buffer[] = [];
+
+        stream.on('data', (chunk: Buffer) => {
+            data.push(chunk);
+        });
+
+        stream.on('end', () => {
+            resolve(Buffer.concat(data));
+        });
+
+        stream.on('error', (err: Error) => {
+            reject(err);
+        });
+    });
+}
+
+export default function compareImages(image1: any, image2: any, options: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+        try {
+            const ignoreTransform: any = {
+                antialiasing: 'ignoreAntialiasing',
+                colors: 'ignoreColors',
+                nothing: 'ignoreNothing',
+            };
+            const ignoreMethod = ignoreTransform[options.ignore] ? ignoreTransform[options.ignore] : 'ignoreNothing';
+
+            const outputOpts = options.output;
+            resemble.outputSettings(outputOpts);
+            let ignoredRect;
+            if (options.ignoreRectangles) {
+                ignoredRect = options.ignoreRectangles.map((it: any) => {
+                    delete it.name;
+                    return [it.left, it.top, it.right - it.left, it.bottom - it.top];
+                });
+            }
+
+            resemble(image1)
+                .compareTo(image2)[ignoreMethod]()
+                .ignoreRectangles(ignoredRect)
+                .onComplete(async (data: any) => {
+                    console.log(data);
+                    const stream = await data.getDiffImage();
+                    const buffer = await streamToBuffer(stream.pack());
+                    data.getBuffer = function () {
+                        return buffer;
+                    };
+                    resolve(data);
+                });
+        } catch (e) {
+            reject(e);
+        }
+    });
+}