@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

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

@@ -0,0 +1,65 @@
+import { checkService } from './index';
+import { Test, Check } from '@models';
+import log from "../lib/logger";
+import { RequestUser } from '@types';
+import { FilterQuery } from 'mongoose';
+import { PaginateOptions } from '../models/plugins/utils';
+
+
+const queryTests = async (filter: FilterQuery<typeof Test>, options: PaginateOptions) => {
+    const tests = await Test.paginate(filter, options);
+    return tests;
+};
+
+const queryTestsDistinct = async (filter: FilterQuery<typeof Test>, options: PaginateOptions) => {
+    const tests = await Test.paginateDistinct({filter: filter ? JSON.stringify(filter) : null}, options);
+    return tests;
+};
+
+const remove = async (id: string, user: RequestUser) => {
+    const logOpts = {
+        scope: 'removeTest',
+        itemType: 'test',
+        ref: id,
+        user: user?.username,
+        msgType: 'REMOVE',
+    };
+    log.info(`remove test with, id: '${id}', user: '${user.username}'`, logOpts);
+
+    try {
+        log.debug(`try to delete all checks associated to test with ID: '${id}'`, logOpts);
+        const checks = await Check.find({ test: id });
+        for (const check of checks) {
+            await checkService.remove(check._id, user);
+        }
+        return Test.findByIdAndDelete(id);
+    } catch (e: unknown) {
+        log.error(`cannot remove test with id: ${id} error: ${(e instanceof Error) ? e.stack : String(e)}`, logOpts);
+        throw new Error();
+    }
+};
+
+const accept = async (id: string, user: RequestUser) => {
+    const logOpts = {
+        scope: 'acceptTest',
+        itemType: 'test',
+        ref: id,
+        user: user?.username,
+        msgType: 'ACCEPT',
+    };
+    log.info(`accept test with, id: '${id}', user: '${user.username}'`, logOpts);
+
+    const checks = await Check.find({ test: id }).exec();
+
+    for (const check of checks) {
+        await checkService.accept(check._id, String(check.actualSnapshotId), user);
+    }
+    return { message: 'success' };
+};
+
+export {
+    queryTests,
+    queryTestsDistinct,
+    remove,
+    accept,
+};

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

@@ -0,0 +1,90 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import httpStatus from 'http-status';
+import { User } from '@models';
+import { ApiError } from '@utils';
+import log from "../lib/logger";
+import { UserCreateReq } from '../schemas/User.schema';
+import { FilterQuery } from 'mongoose';
+import { PaginateOptions } from '../models/plugins/utils';
+
+const createUser = async (userBody: UserCreateReq) => {
+    //  @ts-ignore
+    if (await User.isEmailTaken(userBody.username)) {
+        throw new ApiError(httpStatus.BAD_REQUEST, 'Email already taken');
+    }
+    const logOpts = {
+        msgType: 'CREATE',
+        itemType: 'user',
+        ref: userBody.username,
+        scope: 'createUser',
+    };
+    log.debug(`create the user with name '${userBody.username}', params: '${JSON.stringify(userBody)}'`, logOpts);
+
+    const user = await User.create({ ...userBody, createdDate: Date.now() });
+
+    const updatedUser = await user.setPassword(userBody.password);
+    await updatedUser.save();
+
+    log.debug(`password for user: '${userBody.username}' set successfully`, logOpts);
+
+    const userWithSelectedFields = await User.findById(updatedUser._id)
+        .select('username firstName lastName role createdDate updatedDate createdDate')
+        .exec();
+
+    return userWithSelectedFields;
+};
+const queryUsers = async (filter:  FilterQuery<typeof Test>, options: PaginateOptions) => {
+    const users = await User.paginate(filter, options);
+    return users;
+};
+
+const getUserById = async (id: string) => User.findById(id)
+    .select('username firstName lastName role createdDate updatedDate createdDate')
+    .exec();
+
+const getUserByEmail = async (email: string) => User.findOne({ email });
+
+const updateUserById = async (userId: string, updateBody: UserCreateReq) => {
+    const logOpts = {
+        msgType: 'UPDATE',
+        itemType: 'user',
+        scope: 'updateUserById',
+        ref: userId,
+    };
+
+    log.info(`update user with id: '${userId}' name '${updateBody.username}', params: '${JSON.stringify(updateBody)}'`, logOpts);
+    const user = await getUserById(userId);
+    if (!user) {
+        throw new ApiError(httpStatus.NOT_FOUND, 'User not found');
+    }
+    //  @ts-ignore
+    if (updateBody.email && (await User.isEmailTaken(updateBody.email, userId))) {
+        throw new ApiError(httpStatus.BAD_REQUEST, 'Email already taken');
+    }
+    if (updateBody.password) {
+        log.debug(`update password for '${updateBody.username}'`, logOpts);
+        await user.setPassword(updateBody.password);
+        await user.save();
+        log.debug(`password for '${updateBody.username}' was updated`, logOpts);
+    }
+    log.debug(`user '${updateBody.username}' was updated successfully`, logOpts);
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { password, ...newupdateBody } = updateBody;
+    Object.assign(user, {
+        ...newupdateBody, updatedDate: Date.now(),
+    });
+    await user.save();
+    return user;
+};
+
+const deleteUserById = async (userId: string) => User.findByIdAndDelete(userId).exec();
+
+export {
+    createUser,
+    queryUsers,
+    getUserById,
+    getUserByEmail,
+    updateUserById,
+    deleteUserById,
+};

package/src/server/utils/{ApiError.js → ApiError.ts}

@@ -1,5 +1,8 @@
 class ApiError extends Error {
-    constructor(statusCode, message, isOperational = true, stack = '') {
+    statusCode: number;
+    isOperational: boolean;
+
+    constructor(statusCode: number, message: string, isOperational: boolean = true, stack: string = '') {
         super(message);
         this.statusCode = statusCode;
         this.isOperational = isOperational;
@@ -11,4 +14,4 @@ class ApiError extends Error {
     }
 }
 
-module.exports = ApiError;
+export default ApiError;

package/src/server/utils/ProgressBar.ts

@@ -0,0 +1,35 @@
+import { Response } from 'express';
+
+export class ProgressBar {
+    length: number;
+    percentLenght: number;
+    prevPercent: number;
+    currentPercent: number;
+    progressString: string;
+
+    constructor(length: number) {
+        this.length = length;
+        this.percentLenght = parseFloat((length / 100).toString());
+        this.prevPercent = 0;
+        this.currentPercent = 0;
+        this.progressString = '';
+    }
+
+    isChange(current: number): boolean {
+        this.currentPercent = parseInt((current / this.percentLenght).toString(), 10);
+        if (this.prevPercent === this.currentPercent) {
+            return false;
+        }
+        this.prevPercent = this.currentPercent;
+        this.progressString += '#';
+        return true;
+    }
+
+    writeIfChange(index: number, count: number, fn: (message: string, res: Response) => void, res: Response): void {
+        if (this.isChange(index)) {
+            const placeholderString = Array.from(new Array(99 - this.currentPercent))
+                .reduce((accum) => accum += '.', '');
+            fn(`[${this.progressString}${placeholderString}](${index}/${count})`, res);
+        }
+    }
+}

package/src/server/utils/ServiceResponse.ts

@@ -0,0 +1,18 @@
+export enum ResponseStatus {
+    Success,
+    Failed,
+}
+
+export class ServiceResponse<T = null> {
+    success: boolean;
+    message: string;
+    responseObject: T;
+    statusCode: number;
+
+    constructor(status: ResponseStatus, message: string, responseObject: T, statusCode: number) {
+        this.success = status === ResponseStatus.Success;
+        this.message = message;
+        this.responseObject = responseObject;
+        this.statusCode = statusCode;
+    }
+}

package/src/server/utils/buildIdentObject.ts

@@ -0,0 +1,34 @@
+import { ident } from './ident';
+
+export interface IdentType {
+  name: string;
+  viewport: string;
+  browserName: string;
+  os: string;
+  app: string;
+  branch: string;
+}
+
+type IdentableObject = Partial<IdentType> & {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any;
+}
+
+class MissingIdentFieldError extends Error {
+  constructor(field: string) {
+    super(`Missing required ident field: ${field}`);
+    this.name = 'MissingIdentFieldError';
+  }
+}
+
+export const buildIdentObject = (params: IdentableObject): IdentType => {
+  const result = {} as IdentType;
+  for (const key of ident) {
+    if (key in params && params[key] !== undefined) {
+      result[key as keyof IdentType] = params[key] as string;
+    } else {
+      throw new MissingIdentFieldError(key);
+    }
+  }
+  return result;
+};

package/src/server/utils/calculateAcceptedStatus.ts

@@ -0,0 +1,22 @@
+import { Check } from '@models';
+import { Schema } from 'mongoose';
+
+
+type statusType = 'Bug' | 'Accepted' | 'Unaccepted' | 'Partially';
+
+export const calculateAcceptedStatus = async function calculateAcceptedStatus(testId: string | Schema.Types.ObjectId): Promise<statusType> {
+    const checksInTest = await Check.find({ test: testId });
+    const statuses = checksInTest.map((x) => x.markedAs);
+    if (statuses.length < 1) {
+        return 'Unaccepted';
+    }
+    let testCalculatedStatus: statusType = 'Unaccepted';
+    if (statuses.some((x) => x === 'accepted')) {
+        testCalculatedStatus = 'Partially';
+    }
+    if (statuses.every((x) => x === 'accepted')) {
+        testCalculatedStatus = 'Accepted';
+    }
+    // console.log({ testCalculatedStatus });
+    return testCalculatedStatus;
+};

package/src/server/utils/catchAsync.ts

@@ -0,0 +1,11 @@
+import { Response, NextFunction } from 'express';
+import { ExtRequest } from '@types';
+
+const catchAsync = (fn: (req: ExtRequest, res: Response, next: NextFunction) => Promise<void>) =>
+    (req: ExtRequest, res: Response, next: NextFunction) => {
+        Promise.resolve(fn(req, res, next)).catch((err) => {
+            return next(err);
+        });
+    };
+
+export default catchAsync;

package/src/server/utils/checkIdent.ts

@@ -0,0 +1,4 @@
+import { ident } from './ident';
+
+export const checkIdent = (check: { [key: string]: string }): string =>
+    ident.reduce((accumulator, prop) => `${accumulator}.${check[prop]}`, 'ident');

package/src/server/utils/dateToISO8601.ts

@@ -0,0 +1,5 @@
+const dateToISO8601 = (date: string | Date): string => {
+  return new Date(new Date(date)).toISOString().split('T')[0];
+};
+
+export default dateToISO8601;

package/src/server/utils/deserializeIfJSON.ts

@@ -0,0 +1,9 @@
+import { EJSON } from 'bson';
+import { isJSON } from '.';
+
+const deserializeIfJSON = (text: string) => {
+    if (isJSON(text)) return EJSON.parse(text) || undefined;
+    return text;
+};
+
+export default deserializeIfJSON;

package/src/server/utils/errMsg.ts

@@ -0,0 +1,3 @@
+export const errMsg = (e: unknown) => {
+    return String((e instanceof Error) ? e.stack : e)
+}

package/src/server/utils/{formatISOToDateTime.js → formatISOToDateTime.ts}

@@ -1,6 +1,6 @@
-function formatISOToDateTime(isoDateString) {
+function formatISOToDateTime(isoDateString: string): string {
     const date = new Date(isoDateString);
     return `${date.toISOString().slice(0, 10)} ${date.toTimeString().slice(0, 8)}`;
 }
 
-module.exports = formatISOToDateTime;
+export default formatISOToDateTime;

package/src/server/utils/ident.ts

@@ -0,0 +1 @@
+export const ident = ['name', 'viewport', 'browserName', 'os', 'app', 'branch'];

package/src/server/utils/index.ts

@@ -0,0 +1,24 @@
+import pick from './pick';
+import isJSON from './isJSON';
+import catchAsync from './catchAsync';
+
+export { default as dateToISO8601 } from './dateToISO8601';
+export { ProgressBar } from './ProgressBar';
+export { default as ApiError } from './ApiError';
+export { removeEmptyProperties } from './removeEmptyProperties';
+export { default as deserializeIfJSON } from './deserializeIfJSON';
+export { default as prettyCheckParams } from './prettyCheckParams';
+export { waitUntil } from './waitUntil';
+export { paramsGuard } from './paramsGuard';
+export { buildIdentObject } from './buildIdentObject';
+export { calculateAcceptedStatus } from './calculateAcceptedStatus';
+export { ident } from './ident';
+import subDays from './subDays';
+export { errMsg } from './errMsg';
+
+export {
+    pick,
+    isJSON,
+    catchAsync,
+    subDays,
+};

package/src/server/utils/isJSON.ts

@@ -0,0 +1,14 @@
+const isJSON = (text: string | null): boolean => {
+    if (!text) return false;
+
+    const isValid = /^[\],:{}\s]*$/.test(
+        text
+            .replace(/\\["\\\/bfnrtu]/g, '@')
+            .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+            .replace(/(?:^|:|,)(?:\s*\[)+/g, '')
+    );
+
+    return isValid;
+};
+
+export default isJSON;

package/src/server/utils/paramsGuard.ts

@@ -1,15 +1,16 @@
-import { ZodObject } from 'zod';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ZodObject, SafeParseError } from 'zod';
 
 export const paramsGuard = (params: any, functionName: string, schema: ZodObject<any>) => {
-    const result = schema.safeParse(params)
+    const result = schema.safeParse(params);
     if (result.success) {
-        return true
+        return true;
     } else {
-        const errorDetails = result.error.format()
+        const errorDetails = (result as SafeParseError<any>).error.format();
         throw new Error(`
         Invalid '${functionName}' parameters: ${JSON.stringify(errorDetails)}
-        \n error: ${result.error?.stack || result.error}
+        \n error: ${(result as SafeParseError<any>).error.stack || (result as SafeParseError<any>).error}
         \n params: ${JSON.stringify(params, null, 2)}
-        `)
+        `);
     }
 }

package/src/server/utils/pick.ts

@@ -0,0 +1,17 @@
+/**
+ * Create an object composed of the picked object properties
+ * @param {T} object input object
+ * @param {Array<keyof T>} keys fields to pick
+ * @returns {Partial<T>} new object
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const pick = <T extends Record<string, any>>(object: T, keys: Array<keyof T>): Partial<T> => {
+    return keys.reduce((obj, key) => {
+        if (object && Object.prototype.hasOwnProperty.call(object, key)) {
+            if (object[key] !== undefined) obj[key] = object[key];
+        }
+        return obj;
+    }, {} as Partial<T>);
+};
+
+export default pick;

package/src/server/utils/prettyCheckParams.ts

@@ -0,0 +1,18 @@
+interface Result {
+    domDump?: string;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [key: string]: any;
+}
+
+const prettyCheckParams = (result: Result): string => {
+    if (!result.domDump) {
+        return JSON.stringify(result);
+    }
+    const dump = JSON.parse(result.domDump);
+    const resObs = { ...result };
+    delete resObs.domDump;
+    resObs.domDump = `${JSON.stringify(dump).substr(0, 20)}... and about ${dump.length} items]`;
+    return JSON.stringify(resObs);
+};
+
+export default prettyCheckParams;

package/src/server/utils/removeEmptyProperties.ts

@@ -0,0 +1,5 @@
+export const removeEmptyProperties = (obj: { [key: string]: unknown }): { [key: string]: unknown } =>
+    Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(obj).filter(([_, v]) => (v != null) && (v !== ''))
+    );

package/src/server/utils/{subDays.js → subDays.ts}

@@ -1,7 +1,7 @@
-const subDays = (date, days) => {
+const subDays = (date: Date, days: number): Date => {
     const result = new Date(date);
     result.setDate(result.getDate() - days);
     return result;
 };
 
-module.exports = subDays;
+export default subDays;

package/src/server/utils/validateRequest.ts

@@ -0,0 +1,56 @@
+import { NextFunction, Request, Response } from 'express';
+import StatusCodes from 'http-status';
+import { ZodError, ZodSchema } from 'zod';
+import { ResponseStatus, ServiceResponse } from './ServiceResponse';
+import log from '@logger';
+import { LogOpts } from '@root/src/types';
+import { errMsg } from './errMsg';
+
+const logOpts: LogOpts = {
+  scope: 'validateRequests',
+  itemType: 'type',
+  msgType: 'VALIDATION',
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getReceivedValueFromRequest(request: { body: any; query: any; params: any }, path: (string | number)[]): any {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let currentValue: any = request;
+  path.forEach(segment => {
+    currentValue = currentValue[segment];
+  });
+  return currentValue;
+}
+
+export const validateRequest = (schema: ZodSchema, endpoint = '') => (req: Request, res: Response, next: NextFunction) => {
+  try {
+    schema.parse({
+      body: req.body,
+      query: req.query,
+      params: req.params
+    });
+    next();
+  } catch (err) {
+    
+    if (err instanceof ZodError) {
+      const errors = err.errors.map((e) => {
+        const receivedValue = getReceivedValueFromRequest(
+          { body: req.body, query: req.query, params: req.params },
+          e.path
+        );
+        return `\nError path: '${e.path.join('.')}': \nError ${e.message}, but received ${JSON.stringify(receivedValue)}`;
+      }).join(', ');
+
+      const errorMessage = ` ${endpoint ? '\nValidation error in the endpoint: "' + endpoint + '"' : ''}`
+        + `${errors}, \nHTTP PROPERTIES:\n\tbody: ${JSON.stringify(req.body, null, '\t')}, `
+        +`\n\tquery: ${JSON.stringify(req.query, null, '\t')}, \n\tparams: ${JSON.stringify(req.params, null, '\t')}`;
+
+      const statusCode = StatusCodes.BAD_REQUEST;
+      log.error(errorMessage, logOpts);
+      res.status(statusCode).send(new ServiceResponse<null>(ResponseStatus.Failed, errorMessage, null, statusCode));
+    } else {
+      log.error(`Unexpected error: ${errMsg(err)}`, logOpts);
+      next(err);
+    }
+  }
+};

package/src/server/utils/waitUntil.ts

@@ -0,0 +1,14 @@
+export const waitUntil = async (cb: () => Promise<boolean>, attempts: number = 5, interval: number = 700): Promise<boolean> => {
+    let result = false;
+    let iteration = 0;
+    while (result === false) {
+        result = await cb();
+        await new Promise((r) => setTimeout(r, interval));
+        iteration += 1;
+
+        if (iteration > attempts) {
+            result = true;
+        }
+    }
+    return result;
+};

package/src/tasks/backup.ts

@@ -2,7 +2,7 @@ import { input, confirm } from '@inquirer/prompts';
 import * as fs from 'node:fs'
 import * as path from 'node:path';
 import { execSync } from 'child_process';
-import { config } from '../../config';
+import { config } from '../server/config';
 
 const run = async () => {
     const backupFolder: string = config.backupsFolder;

package/src/tasks/lib/index.ts

@@ -0,0 +1,13 @@
+import { Snapshot, Check, Test, Run, App, Suite, User, Baseline, Log } from '../../server/models';
+
+export {
+    User,
+    Snapshot,
+    Check,
+    Test,
+    Run,
+    App,
+    Suite,
+    Baseline,
+    Log
+};

package/src/tasks/lib/utils.ts

@@ -0,0 +1,14 @@
+import mongoose from 'mongoose';
+import { config } from "../../server/config";
+
+const connect = async () => {
+    const connection = await mongoose.connect(config.connectionString, {});
+    console.log(`Mongoose default connection open to: '${config.connectionString}', models: '${Object.keys(connection.models).join(', ')}'`);
+    return connection;
+};
+
+export const runMongoCode = async (cb: () => Promise<void>) => {
+    await connect();
+    await cb();
+    await mongoose.connection.close();
+};

package/src/tasks/migrations/2.0.migration.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-await-in-loop,no-restricted-syntax */
 require('../../server/models');
 
-const utils = require('../lib/utils');
-const { Check, Test, Run, Suite } = require('../lib/common');
+const utils = require('../lib');
+const { Check, Test, Run, Suite } = require('../lib');
 
 async function task() {
     await utils.runMongoCode(async () => {

package/src/tasks/reindex.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import '../server/models';
+import { runMongoCode } from './lib/utils';
+import { User, Snapshot, Check, Test, Run, Log, App, Suite, Baseline } from './lib/index';
+
+(async () => {
+    await runMongoCode(async () => {
+        return new Promise<void>((resolve) => {
+            const result: any[] = [];
+            [User, Snapshot, Check, Test, Run, Log, App, Suite, Baseline].forEach((model) => {
+                result.push(
+                    model.collection.dropIndexes()
+                        .then(() => {
+                            console.log(`Drop: '${model.collection.name}'`);
+                        })
+                        .catch((err: Error) => {
+                            console.log(`Cannot drop index '${model.collection.name}', error: '${err}'`);
+                        })
+                );
+            });
+
+            Promise.all(result)
+                .catch((err: Error) => {
+                    console.log('ERROR:');
+                    console.error(err);
+                })
+                .then(() => {
+                    console.log('End of reindex task');
+                });
+
+            resolve();
+        });
+    });
+})();

package/src/tasks/restore.ts

@@ -3,7 +3,7 @@ import { input, confirm, select } from '@inquirer/prompts';
 import * as fs from 'node:fs'
 import * as path from 'node:path';
 import { execSync } from 'child_process';
-import { config } from '../../config';
+import { config } from '../server/config';
 
 const run = async () => {
     const backupFolder = config.backupsFolder;

package/src/types/ExtRequest.ts

@@ -0,0 +1,10 @@
+import { Request } from 'express';
+import { RequestUser } from './RequestUser';
+
+export interface ExtRequest extends Request {
+    user?: RequestUser;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    files?: any;
+}
+
+export type ERequest = ExtRequest | Request; 

package/src/types/LogOpts.ts

@@ -0,0 +1,20 @@
+// import { MetaData } from "../server/lib/logger";
+
+// // export interface LogOpts {
+// //     scope: string;
+// //     user?: string;
+// //     itemType?: string;
+// //     msgType: string;
+// //     ref?: string;
+// //   }
+
+//   export type LogOpts = MetaData
+
+  export interface LogOpts {
+    [key: string]: unknown;
+    user?: string;
+    ref?: string;
+    msgType?: string;
+    itemType?: string;
+    scope?: string;
+}