@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

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

@@ -0,0 +1 @@
+export { getDiff } from "./comparator";

package/src/server/middlewares/{authorization.js → authorization.ts}

@@ -1,17 +1,23 @@
-const httpStatus = require('http-status');
-const ApiError = require('../utils/ApiError');
-const catchAsync = require('../utils/catchAsync');
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import httpStatus from 'http-status';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { Response, NextFunction } from 'express';
+import { ApiError } from '@utils';
+import { catchAsync } from '@utils';
+import log from '@lib/logger';
+import { ExtRequest } from '@types';
+import { appSettings } from "@settings";
+// import { createLog } from '@controllers/logs.controller';
+// import AppSettings from '@models/AppSettings';
 
-const $this = this;
-$this.logMeta = {
-    scope: 'authorization',
-    msgType: 'AUTHORIZATION',
-};
 
-exports.authorization = (type) => {
-    const types = {
-        admin: catchAsync(async (req, res, next) => {
-            if (!(await global.AppSettings.isAuthEnabled())) {
+export const authorization = (type: string) => {
+
+    const types: { [key: string]: (req: any, res: any, next: NextFunction) => any } = {
+        admin: catchAsync(async (req: ExtRequest, res: Response, next: NextFunction) => {
+            const AppSettings = await appSettings;
+            if (!(await AppSettings.isAuthEnabled())) {
                 return next();
             }
             if (req.user?.role === 'admin') {
@@ -21,8 +27,11 @@ exports.authorization = (type) => {
             log.warn(`user authorization: '${req.user?.username}' wrong role, type: '${type}'`);
             throw new ApiError(httpStatus.FORBIDDEN, 'Authorization Error - wrong Role');
         }),
-        user: catchAsync(async (req, res, next) => {
-            if (!(await global.AppSettings.isAuthEnabled())) {
+        user: catchAsync(async (req: ExtRequest, res: Response, next: NextFunction) => {
+            const AppSettings = await appSettings;
+
+            // @ts-ignore
+            if (!(await AppSettings.isAuthEnabled())) {
                 return next();
             }
             if (req.user?.role === 'admin') {

package/src/server/middlewares/compressionFilter.ts

@@ -0,0 +1,9 @@
+import { Request, Response } from "express";
+import compression from 'compression';
+
+export function compressionFilter(req: Request, res: Response) {
+    if (req.headers['x-no-compression']) {
+        return false;
+    }
+    return compression.filter(req, res);
+}

package/src/server/middlewares/disableCors.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Request, Response, NextFunction } from 'express';
+import { config } from '@config';
+
+// disable CORS for development purposes
+export const disableCors = (req: Request, res: Response, next: NextFunction): void => {
+    if (!config.disableCors) return next();
+    // Website you wish to allow to connect
+    // res.setHeader('Access-Control-Allow-Origin', 'http://localhost:8080');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('X-Frame-Options', 'ALLOWALL');
+    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+
+    // Request methods you wish to allow
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
+
+    // Request headers you wish to allow
+    res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
+
+    // Set to true if you need the website to include cookies in the requests sent
+    // to the API (e.g. in case you use sessions)
+    res.setHeader('Access-Control-Allow-Credentials', 'true');
+
+    // Handle preflight requests
+    if (req.method === 'OPTIONS') {
+        res.status(200).end();
+        return;
+    }
+
+    // Pass to next layer of middleware
+    return next();
+};

package/src/server/{lib/ensureLogin/ensureLoggedIn.js → middlewares/ensureLogin/ensureLoggedIn.ts}

@@ -1,3 +1,7 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-nocheck
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 /**
  * Ensure that a user is logged in before proceeding to next route middleware.
  *
@@ -31,16 +35,17 @@
  * @return {Function}
  * @api public
  */
-const { User } = require('../../models');
 
-const $this = this;
-$this.logMeta = {
-    scope: 'Authentication',
-    msgType: 'LOGIN',
-};
+import { Request, Response, NextFunction } from 'express';
+import { User } from '@models';
+import log from "../../lib/logger";
+import { ExtRequest } from '../../../types/ExtRequest';
+import { appSettings } from "@settings";
+import { env } from "@/server/envConfig";
+
+
 
-// eslint-disable-next-line consistent-return
-const handleBasicAuth = async (req) => {
+const handleBasicAuth = async (req: ExtRequest): Promise<any> => {
     const logOpts = {
         scope: 'handleBasicAuth',
         msgType: 'AUTH_API',
@@ -49,17 +54,17 @@ const handleBasicAuth = async (req) => {
     if (req.isAuthenticated()) {
         return { type: 'success', status: 200 };
     }
-    if (!(await global.AppSettings.isAuthEnabled())) {
+    const AppSettings = await appSettings;
+    if (!(await AppSettings.isAuthEnabled())) {
         const guest = await User.findOne({ username: 'Guest' });
-        // noinspection UnnecessaryLocalVariableJS
         const result = new Promise((resolve) => {
-            req.logIn(guest, (err) => {
+            req.logIn(guest, (err: any) => {
                 if (err) {
-                    log.error(`cannot find quest user: '${err}'`, $this, logOpts);
+                    log.error(`cannot find guest user: '${err}'`, logOpts);
                     resolve({
                         type: 'redirect',
                         status: 301,
-                        value: `/auth?=Error: cannot find quest user: ${err}`,
+                        value: `/auth?=Error: cannot find guest user: ${err}`,
                         user: null,
                     });
                 } else {
@@ -75,26 +80,25 @@ const handleBasicAuth = async (req) => {
         return result;
     }
 
-    const result = {
+    const result: any = {
         type: 'error',
         status: 400,
         value: '',
         user: null,
     };
-
-    if ((await global.AppSettings.isAuthEnabled())
-        && ((await global.AppSettings.isFirstRun()))
-        && process.env.SYNGRISI_DISABLE_FIRST_RUN !== '1'
+    if ((await AppSettings.isAuthEnabled())
+        && ((await AppSettings.isFirstRun()))
+        && !env.SYNGRISI_DISABLE_FIRST_RUN
     ) {
-        log.info('first run, set admin password', $this, logOpts);
+        log.info('first run, set admin password', logOpts);
         result.type = 'redirect';
         result.status = 301;
         result.value = '/auth/change?first_run=true';
         return result;
     }
 
-    if (await global.AppSettings.isAuthEnabled()) {
-        log.info(`user is not authenticated - ${req.originalUrl}`, $this, logOpts);
+    if (await AppSettings.isAuthEnabled()) {
+        log.info(`user is not authenticated, will redirected - ${req.originalUrl}`, logOpts);
 
         result.type = 'redirect';
         result.status = 301;
@@ -109,42 +113,37 @@ const handleBasicAuth = async (req) => {
     }
 };
 
-exports.ensureLoggedIn = function ensureLoggedIn() {
-    // eslint-disable-next-line consistent-return
-    return async (req, res, next) => {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function ensureLoggedIn(options?: any): (req: Request, res: Response, next: NextFunction) => Promise<void> {
+    return async (req: Request, res: Response, next: NextFunction) => {
         const result = await handleBasicAuth(req);
-        // log.silly(result, {
-        //     scope: 'ensureLoggedIn',
-        //     msgType: 'AUTH_API',
-        // }, $this);
         req.user = result.user || req.user;
         if (result.type === 'success') {
             return next();
         }
-        res.status(result.status)
-            .redirect(result.value);
+        res.status(result.status).redirect(result.value);
         return next('redirect');
     };
-};
+}
 
-const handleAPIAuth = async (hashedApiKey) => {
+const handleAPIAuth = async (hashedApiKey: string): Promise<any> => {
     const logOpts = {
         scope: 'handleAPIAuth',
         msgType: 'AUTH_API',
     };
 
-    const result = {
+    const result: any = {
         status: 400,
         type: 'error',
         value: '',
         user: null,
     };
-
-    if (!(await global.AppSettings.isAuthEnabled())) {
+    const AppSettings = await appSettings; 
+    if (!(await AppSettings.isAuthEnabled())) {
         const guest = await User.findOne({ username: 'Guest' });
 
         if (!guest) {
-            log.error('cannot find Guest user');
+            log.error('cannot find Guest user', logOpts);
             result.type = 'error';
             result.value = 'cannot find Guest user';
             return result;
@@ -172,52 +171,50 @@ const handleAPIAuth = async (hashedApiKey) => {
         result.value = 'wrong API key';
         return result;
     }
-    log.debug('authenticated', $this, { ...logOpts, ...{ user: user?.username } });
+    log.debug('authenticated', { ...logOpts, ...{ user: user?.username } });
     result.type = 'success';
     result.status = 200;
     result.user = user;
     return result;
 };
 
-exports.ensureApiKey = function ensureApiKey() {
+export function ensureApiKey(): (req: Request, res: Response, next: NextFunction) => Promise<void> {
     const logOpts = {
         scope: 'ensureApiKey',
         msgType: 'AUTH_API',
     };
-    // eslint-disable-next-line consistent-return
-    return async (req, res, next) => {
+    return async (req: Request, res: Response, next: NextFunction) => {
         log.silly(`headers: ${JSON.stringify(req.headers, null, '..')}`, logOpts);
-        log.silly(`SYNGRISI_AUTH: '${process.env.SYNGRISI_AUTH}'`);
+        log.silly(`SYNGRISI_AUTH: '${env.SYNGRISI_AUTH}'`);
         const hashedApiKey = req.headers.apikey || req.query.apikey;
         const result = await handleAPIAuth(hashedApiKey);
         req.user = req.user || result.user;
         req.headers.apikey = result?.user?.apiKey || req?.headers?.apikey;
         if (result.type !== 'success') {
-            log.info(`${result.value} - ${req.originalUrl}`, $this, logOpts);
-            res.status(result.status)
-                .json({ error: result.value });
+            log.info(`${result.value} - ${req.originalUrl}`, logOpts);
+            res.status(result.status).json({ error: result.value });
             return next(new Error(result.value));
         }
         return next();
     };
-};
+}
 
-exports.ensureLoggedInOrApiKey = () => async (req, res, next) => {
-    const basicAuthResult = await handleBasicAuth(req);
+export function ensureLoggedInOrApiKey(): (req: Request, res: Response, next: NextFunction) => Promise<void> {
+    return async (req: Request, res: Response, next: NextFunction) => {
+        const basicAuthResult = await handleBasicAuth(req);
 
-    const hashedApiKey = req.headers.apikey || req.query.apikey;
-    const apiKeyResult = await handleAPIAuth(hashedApiKey);
-    req.user = req.user || apiKeyResult.user;
-
-    if (
-        (basicAuthResult.type !== 'success')
-        && (apiKeyResult.type !== 'success')
-    ) {
-        log.info(`Unauthorized - ${req.originalUrl}`);
-        // res.status(401).json({ error: `${`${apiKeyResult.value} ${basicAuthResult.value}`} - ${req.originalUrl}` });
-        res.status(401)
-            .json({ error: `Unauthorized - ${req.originalUrl}` });
-        return next(new Error(`Unauthorized - ${req.originalUrl}`));
-    }
-    return next();
-};
+        const hashedApiKey = req.headers.apikey || req.query.apikey;
+        const apiKeyResult = await handleAPIAuth(hashedApiKey);
+        req.user = req.user || apiKeyResult.user;
+
+        if (
+            (basicAuthResult.type !== 'success')
+            && (apiKeyResult.type !== 'success')
+        ) {
+            log.info(`Unauthorized - ${req.originalUrl}`);
+            res.status(401).json({ error: `Unauthorized - ${req.originalUrl}` });
+            return next(new Error(`Unauthorized - ${req.originalUrl}`));
+        }
+        return next();
+    };
+}

package/src/server/middlewares/ensureLogin/index.ts

@@ -0,0 +1,2 @@
+export { ensureLoggedIn } from "./ensureLoggedIn";
+export { ensureApiKey } from "./ensureLoggedIn";

package/src/server/middlewares/errorHandler.ts

@@ -0,0 +1,42 @@
+import { ErrorRequestHandler, RequestHandler } from 'express';
+import httpStatus from 'http-status';
+import { Request, Response } from "express";
+import { env } from "@env";
+import log from "@logger";
+import { ApiError } from '../utils';
+import StatusCodes from 'http-status';
+
+
+const unexpectedRequest: RequestHandler = (req: Request, res: Response) => {
+  res.status(httpStatus.NOT_FOUND).json({ error: `url: '${req.originalUrl}' not found` });
+};
+
+const addErrorToRequestLog: ErrorRequestHandler = (err, _req, res, next) => {
+  log.error(err);
+  res.locals.err = err;
+  if (env.NODE_ENV !== "production") {
+    if (err instanceof ApiError) {
+      return res.status(err.statusCode)
+        .json({
+          name: err.name,
+          type: 'ApiError',
+          message: err.message,
+          status: err.statusCode,
+          // sanitise stacktrace
+          stacktrace: JSON.stringify(err.stack),
+        });
+    }
+    else if(err instanceof Error) {
+      return res.status(StatusCodes.INTERNAL_SERVER_ERROR)
+        .json({
+          name: err.name,
+          type: 'Error',
+          message: err.message,
+          stacktrace: JSON.stringify(err.stack),
+        });
+    }
+  }
+  next(err);
+};
+
+export default () => [unexpectedRequest, addErrorToRequestLog];

package/src/server/middlewares/index.ts

@@ -0,0 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export { disableCors } from './disableCors';
+export { authorization } from './authorization';
+export { compressionFilter } from './compressionFilter';

package/src/server/models/App.model.ts

@@ -0,0 +1,42 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface AppDocument extends Document {
+    name: string;
+    description?: string;
+    version?: string;
+    updatedDate?: Date;
+    createdDate?: Date;
+    meta?: Record<string, unknown>;
+}
+
+const AppSchema: Schema<AppDocument> = new Schema({
+    name: {
+        type: String,
+        default: 'Others',
+        unique: true,
+        required: [true, 'AppSchema: The "name" field must be required'],
+    },
+    description: {
+        type: String,
+    },
+    version: {
+        type: String,
+    },
+    updatedDate: {
+        type: Date,
+    },
+    createdDate: {
+        type: Date,
+    },
+    meta: {
+        type: Object,
+    },
+});
+
+AppSchema.plugin(paginate);
+AppSchema.plugin(toJSON);
+
+const App: Model<AppDocument> = mongoose.model<AppDocument>('VRSApp', AppSchema);
+export default App as PluginExtededModel<AppDocument>;

package/src/server/models/AppSettings.model.ts

@@ -0,0 +1,48 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface AppSettingsDocument extends Document {
+    name: string;
+    label: string;
+    description?: string;
+    type: { [key: string]: string };
+    value: Schema.Types.Mixed;
+    env_variable?: string;
+    enabled?: boolean;
+}
+
+const AppSettingsSchema: Schema<AppSettingsDocument> = new Schema({
+    name: {
+        type: String,
+        unique: true,
+        required: [true, 'AppSettingsSchema: The "name" field must be required'],
+    },
+    label: {
+        type: String,
+        required: [true, 'AppSettingsSchema: The "label" field must be required'],
+    },
+    description: {
+        type: String,
+    },
+    type: {
+        type: String,
+        required: [true, 'AppSettingsSchema: The "type" field must be required'],
+    },
+    value: {
+        type: Schema.Types.Mixed,
+        required: [true, 'AppSettingsSchema: The "value" field must be required'],
+    },
+    env_variable: {
+        type: String,
+    },
+    enabled: {
+        type: Boolean,
+    },
+});
+
+AppSettingsSchema.plugin(toJSON);
+
+const AppSettings: Model<AppSettingsDocument> = mongoose.model<AppSettingsDocument>('VRSAppSettings', AppSettingsSchema);
+export default AppSettings as PluginExtededModel<AppSettingsDocument>;
+

package/src/server/models/Baseline.model.ts

@@ -0,0 +1,98 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface BaselineDocument extends Document {
+    snapshootId: Schema.Types.ObjectId;
+    name: string;
+    app: Schema.Types.ObjectId;
+    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?: Record<string, unknown>;
+}
+
+const BaselineSchema: Schema<BaselineDocument> = new Schema({
+    snapshootId: {
+        type: Schema.Types.ObjectId,
+    },
+    name: {
+        type: String,
+        required: [true, 'VRSBaselineSchema: The "name" field must be required'],
+    },
+    app: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSApp',
+        required: [true, 'VRSBaselineSchema: The "app" field must be required'],
+    },
+    branch: {
+        type: String,
+    },
+    browserName: {
+        type: String,
+    },
+    browserVersion: {
+        type: String,
+    },
+    browserFullVersion: {
+        type: String,
+    },
+    viewport: {
+        type: String,
+    },
+    os: {
+        type: String,
+    },
+    markedAs: {
+        type: String,
+        enum: ['bug', 'accepted'],
+    },
+    lastMarkedDate: {
+        type: Date,
+    },
+    createdDate: {
+        type: Date,
+    },
+    updatedDate: {
+        type: Date,
+    },
+    markedById: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSUser',
+    },
+    markedByUsername: {
+        type: String,
+    },
+    ignoreRegions: {
+        type: String,
+    },
+    boundRegions: {
+        type: String,
+    },
+    matchType: {
+        type: String,
+        enum: ['antialiasing', 'nothing', 'colors'],
+    },
+    meta: {
+        type: Object,
+    },
+});
+
+BaselineSchema.plugin(toJSON);
+BaselineSchema.plugin(paginate);
+
+const Baseline: Model<BaselineDocument> = mongoose.model<BaselineDocument>('VRSBaseline', BaselineSchema);
+export default Baseline as PluginExtededModel<BaselineDocument>;
+