@syngrisi/syngrisi 2.2.1

package/src/server/models/plugins/paginateDistinct.plugin.js

@@ -0,0 +1,80 @@
+/* eslint-disable no-param-reassign, valid-jsdoc */
+const { EJSON } = require('bson');
+
+const paginateDistinct = (schema) => {
+    /**
+     * @typedef {Object} QueryResult
+     * @property {Document[]} results - Results found
+     * @property {number} page - Current page
+     * @property {number} limit - Maximum number of results per page
+     * @property {number} totalPages - Total number of pages
+     * @property {number} totalResults - Total number of documents
+     */
+    /**
+     * Query for documents with pagination
+     * @param {Object} [filter] - Mongo filter
+     * @param {Object} [options] - Query options
+     * @param {string} [options.sortBy] - Sorting criteria using the format: sortField:(desc|asc).
+     * Multiple sorting criteria should be separated by commas (,)
+     * @param {string} [options.populate] - Populate data fields. Hierarchy of fields should be separated by (.).
+     * Multiple populating criteria should be separated by commas (,)
+     * @param {number} [options.limit] - Maximum number of results per page (default = 10)
+     * @param {number} [options.page] - Current page (default = 1)
+     * @returns {Promise<QueryResult>}
+     */
+    // eslint-disable-next-line func-names
+    schema.statics.paginateDistinct = async function (filter, options) {
+        let sort = {};
+        if (options.sortBy) {
+            options.sortBy.split(',')
+                .forEach((sortOption) => {
+                    const [key, order] = sortOption.split(':');
+                    sort[key] = (order === 'desc') ? -1 : 1;
+                });
+        } else {
+            sort = { _id: -1 };
+        }
+
+        let limit = options.limit && parseInt(options.limit, 10) >= 0 ? parseInt(options.limit, 10) : 10;
+        limit = limit === 0 ? 9007199254740991 : limit;
+        const page = options.page && parseInt(options.page, 10) > 0 ? parseInt(options.page, 10) : 1;
+        const skip = (page - 1) * limit;
+
+        const groupAggregateObj = { $group: { _id: `$${options.field}` } };
+
+        const documentsCount = (await this.aggregate([groupAggregateObj])
+            .exec()).length;
+        const aggregateArr = [
+            { $match: EJSON.parse(filter.filter || '{}') },
+            groupAggregateObj,
+            { $sort: sort },
+            { $skip: skip },
+            { $limit: limit },
+        ];
+        const aggregatedDocs = (await this.aggregate(aggregateArr))
+            .filter((x) => x._id)
+            .map((x) => {
+                if (x[options.field]) {
+                    return x[options.field][0];
+                }
+                return { name: x._id };
+            });
+
+        return Promise.all([documentsCount, aggregatedDocs])
+            .then((values) => {
+                const [totalResults, results] = values;
+                const totalPages = Math.ceil(totalResults / limit);
+                const result = {
+                    results,
+                    page,
+                    limit,
+                    totalPages,
+                    totalResults,
+                    timestamp: new Date() / 1,
+                };
+                return Promise.resolve(result);
+            });
+    };
+};
+
+module.exports = paginateDistinct;

package/src/server/models/plugins/toJSON.plugin.js

@@ -0,0 +1,44 @@
+/* eslint-disable no-param-reassign */
+
+/**
+ * A mongoose schema plugin which applies the following in the toJSON transform call:
+ *  - removes __v, createdAt, updatedAt, and any path that has private: true
+ *  - replaces _id with id
+ */
+
+const deleteAtPath = (obj, path, index) => {
+    if (index === path.length - 1) {
+        delete obj[path[index]];
+        return;
+    }
+    deleteAtPath(obj[path[index]], path, index + 1);
+};
+
+const toJSON = (schema) => {
+    let transform;
+    if (schema.options.toJSON && schema.options.toJSON.transform) {
+        transform = schema.options.toJSON.transform;
+    }
+
+    schema.options.toJSON = Object.assign(schema.options.toJSON || {}, {
+        transform(doc, ret, options) {
+            Object.keys(schema.paths).forEach((path) => {
+                if (schema.paths[path].options && schema.paths[path].options.private) {
+                    deleteAtPath(ret, path.split('.'), 0);
+                }
+            });
+
+            ret.id = ret._id.toString();
+            // delete ret._id;
+            // eslint-disable-next-line no-underscore-dangle
+            delete ret.__v;
+            delete ret.createdAt;
+            delete ret.updatedAt;
+            if (transform) {
+                return transform(doc, ret, options);
+            }
+        },
+    });
+};
+
+module.exports = toJSON;

package/src/server/routes/ui/admin.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const path = require('path');
+const httpStatus = require('http-status');
+
+const catchAsync = require('../../utils/catchAsync');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+const { authorization } = require('../../middlewares/authorization');
+
+const router = express.Router();
+
+const adminController = catchAsync(async (req, res) => {
+    res.status(httpStatus.OK)
+        .sendFile(path.normalize(path.join(`${__dirname}./../../../../mvc/views/react/admin/index.html`)));
+});
+
+router.get('*', ensureLoggedIn(),
+    authorization('admin'),
+    adminController);
+
+module.exports = router;

package/src/server/routes/ui/auth.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const path = require('path');
+const httpStatus = require('http-status');
+
+const catchAsync = require('../../utils/catchAsync');
+
+const router = express.Router();
+
+const authController = catchAsync(async (req, res) => {
+    res.status(httpStatus.OK).sendFile(path.normalize(path.join(`${__dirname}./../../../../mvc/views/react/auth/index.html`)));
+});
+
+router.get('*', authController);
+
+module.exports = router;

package/src/server/routes/ui/index.js

@@ -0,0 +1,19 @@
+const express = require('express');
+const path = require('path');
+const httpStatus = require('http-status');
+
+const catchAsync = require('../../utils/catchAsync');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router.get(
+    '',
+    ensureLoggedIn(),
+    catchAsync(async (req, res) => {
+        res.status(httpStatus.OK)
+            .sendFile(path.normalize(path.join(`${__dirname}./../../../../mvc/views/react/index2/index.html`)));
+    })
+);
+
+module.exports = router;

package/src/server/routes/v1/app.route.js

@@ -0,0 +1,9 @@
+const express = require('express');
+const appController = require('../../controllers/app.controller');
+
+const router = express.Router();
+
+router.get('/info', appController.info);
+router.get('/', appController.get);
+
+module.exports = router;

package/src/server/routes/v1/auth.route.js

@@ -0,0 +1,12 @@
+const express = require('express');
+const authController = require('../../controllers/auth.controller');
+
+const router = express.Router();
+
+router.get('/logout', authController.logout);
+router.get('/apikey', authController.apikey);
+router.post('/login', authController.login);
+router.post('/change', authController.changePassword);
+router.post('/change_first_run', authController.changePasswordFirstRun);
+
+module.exports = router;

package/src/server/routes/v1/baselines.route.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const { baselinesController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(ensureLoggedIn(), baselinesController.get);
+
+router.route('/:id')
+    .put(ensureLoggedIn(), baselinesController.put);
+
+module.exports = router;

package/src/server/routes/v1/checks.route.js

@@ -0,0 +1,25 @@
+const express = require('express');
+const { checksController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(ensureLoggedIn(), checksController.get);
+
+router
+    .route('/:id')
+    .delete(ensureLoggedIn(), checksController.remove);
+
+// update
+router.route('/:id')
+    .put(ensureLoggedIn(), checksController.update);
+
+router.route('/accept/:id')
+    .put(ensureLoggedIn(), checksController.accept);
+
+router.route('/get_via_post')
+    .post(ensureLoggedIn(), checksController.getViaPost);
+
+module.exports = router;

package/src/server/routes/v1/client.route.js

@@ -0,0 +1,39 @@
+const express = require('express');
+const Bottleneck = require('bottleneck/es5');
+const { clientController } = require('../../controllers');
+const { ensureApiKey } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+global.limiter.startSession = new Bottleneck({
+    maxConcurrent: 1,
+});
+
+router
+    .route('/startSession')
+    .post(ensureApiKey(),
+        async (req, res, next) => global.limiter.startSession.schedule(
+            () => clientController.startSession(req, res, next)
+        ));
+
+router
+    .route('/stopSession/:testid')
+    .post(ensureApiKey(), clientController.endSession);
+
+router
+    .route('/createCheck')
+    .post(ensureApiKey(), clientController.createCheck);
+
+router
+    .route('/getIdent')
+    .get(ensureApiKey(), clientController.getIdent);
+
+router
+    .route('/baselines')
+    .get(ensureApiKey(), clientController.getBaselines);
+
+router
+    .route('/snapshots')
+    .get(ensureApiKey(), clientController.getSnapshots);
+
+module.exports = router;

package/src/server/routes/v1/index.js

@@ -0,0 +1,82 @@
+const express = require('express');
+const authRoute = require('./auth.route');
+const appRoute = require('./app.route');
+const testsRoute = require('./test.route');
+const usersRoute = require('./users.route');
+const logsRoute = require('./logs.route');
+const runsRoute = require('./runs.route');
+const snapshotRoute = require('./snapshots.route');
+const checkRoute = require('./checks.route');
+const baselinesRoute = require('./baselines.route');
+const suitesRoute = require('./suites.route');
+const settingsRoute = require('./settings.route');
+const testDistinctRoute = require('./test_distinct.route');
+const tasksRoute = require('./tasks.route');
+const clientRoute = require('./client.route');
+
+const router = express.Router();
+
+const defaultRoutes = [
+    {
+        path: '/auth',
+        route: authRoute,
+    },
+    {
+        path: '/client',
+        route: clientRoute,
+    },
+    {
+        path: '/tasks',
+        route: tasksRoute,
+    },
+    {
+        path: '/users',
+        route: usersRoute,
+    },
+    {
+        path: '/app',
+        route: appRoute,
+    },
+    {
+        path: '/tests',
+        route: testsRoute,
+    },
+    {
+        path: '/logs',
+        route: logsRoute,
+    },
+    {
+        path: '/runs',
+        route: runsRoute,
+    },
+    {
+        path: '/snapshots',
+        route: snapshotRoute,
+    },
+    {
+        path: '/checks',
+        route: checkRoute,
+    },
+    {
+        path: '/baselines',
+        route: baselinesRoute,
+    },
+    {
+        path: '/suites',
+        route: suitesRoute,
+    },
+    {
+        path: '/settings',
+        route: settingsRoute,
+    },
+    {
+        path: '/test-distinct',
+        route: testDistinctRoute,
+    },
+];
+
+defaultRoutes.forEach((route) => {
+    router.use(route.path, route.route);
+});
+
+module.exports = router;

package/src/server/routes/v1/logs.route.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const { logsController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(ensureLoggedIn(), logsController.getLogs)
+    .post(ensureLoggedIn(), logsController.createLog);
+
+router
+    .route('/distinct')
+    .get(ensureLoggedIn(), logsController.distinct);
+
+module.exports = router;

package/src/server/routes/v1/runs.route.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const { runsController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(ensureLoggedIn(), runsController.get);
+
+router
+    .route('/:id')
+    .delete(ensureLoggedIn(), runsController.remove);
+
+module.exports = router;

package/src/server/routes/v1/settings.route.js

@@ -0,0 +1,23 @@
+const express = require('express');
+const { settingsController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+const { authorization } = require('../../middlewares/authorization');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(
+        ensureLoggedIn(),
+        authorization('admin'),
+        settingsController.getSettings
+    );
+router
+    .route('/:name')
+    .patch(
+        ensureLoggedIn(),
+        authorization('admin'),
+        settingsController.updateSetting
+    );
+
+module.exports = router;

package/src/server/routes/v1/snapshots.route.js

@@ -0,0 +1,11 @@
+const express = require('express');
+const { snapshotController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(ensureLoggedIn(), snapshotController.get);
+
+module.exports = router;

package/src/server/routes/v1/suites.route.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const { suiteController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/')
+    .get(ensureLoggedIn(), suiteController.get);
+
+router
+    .route('/:id')
+    .delete(ensureLoggedIn(), suiteController.remove);
+
+module.exports = router;

package/src/server/routes/v1/tasks.route.js

@@ -0,0 +1,59 @@
+const express = require('express');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+const { authorization } = require('../../middlewares/authorization');
+const { tasksController } = require('../../controllers');
+
+const router = express.Router();
+
+router
+    .route('/task_test')
+    .get(
+        ensureLoggedIn(),
+        authorization('admin'),
+        tasksController.task_test
+    );
+
+router
+    .route('/task_handle_old_checks')
+    .get(
+        ensureLoggedIn(),
+        authorization('admin'),
+        tasksController.task_handle_old_checks
+    );
+
+router
+    .route('/task_handle_database_consistency')
+    .get(
+        ensureLoggedIn(),
+        authorization('admin'),
+        tasksController.task_handle_database_consistency
+    );
+
+router
+    .route('/task_remove_old_logs')
+    .get(
+        ensureLoggedIn(),
+        authorization('admin'),
+        tasksController.task_remove_old_logs
+    );
+
+router
+    .route('/loadTestUser')
+    .get(
+        ensureLoggedIn(),
+        tasksController.loadTestUser
+    );
+
+router
+    .route('/status')
+    .get(
+        tasksController.status
+    );
+
+router
+    .route('/screenshots')
+    .get(
+        tasksController.screenshots
+    );
+
+module.exports = router;

package/src/server/routes/v1/test.route.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const testController = require('../../controllers/test.controller');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router.route('/')
+    .get(ensureLoggedIn(), testController.getTest);
+
+router.route('/distinct')
+    .get(ensureLoggedIn(), testController.distinct);
+router
+    .route('/:id')
+    .delete(ensureLoggedIn(), testController.remove);
+
+router
+    .route('/accept/:id')
+    .put(ensureLoggedIn(), testController.accept);
+
+module.exports = router;

package/src/server/routes/v1/test_distinct.route.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const { testsController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+
+const router = express.Router();
+
+router
+    .route('/:id')
+    .get(
+        ensureLoggedIn(),
+        testsController.distinct
+    );
+
+module.exports = router;

package/src/server/routes/v1/users.route.js

@@ -0,0 +1,36 @@
+const express = require('express');
+const { userController } = require('../../controllers');
+const { ensureLoggedIn } = require('../../lib/ensureLogin/ensureLoggedIn');
+const { authorization } = require('../../middlewares/authorization');
+
+const router = express.Router();
+
+router.get('/current', userController.current);
+
+router
+    .route('/')
+    .post(
+        ensureLoggedIn(),
+        authorization('admin'),
+        userController.createUser
+    )
+    .get(
+        ensureLoggedIn(),
+        authorization('user'),
+        userController.getUsers
+    );
+
+router
+    .route('/:userId')
+    .patch(
+        ensureLoggedIn(),
+        authorization('admin'),
+        userController.updateUser
+    )
+    .delete(
+        ensureLoggedIn(),
+        authorization('admin'),
+        userController.deleteUser
+    );
+
+module.exports = router;

package/src/server/schemas/createCheck.shema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export const createCheckParamsSchema = z.object({
+    branch: z.string().min(1),
+    appName: z.string().min(1),
+    suitename: z.string().min(1),
+    testid: z.string().regex(/^[a-f0-9]{24}$/), // Regex for 24 hex characters
+    name: z.string().min(1),
+    viewport: z.string().regex(/^\d+x\d+$/), // "WidthxHeight" format
+    browserName: z.string().min(1),
+    browserVersion: z.string().min(1),
+    browserFullVersion: z.string(),
+    os: z.string().min(1),
+    hashcode: z.string().length(128) // Assuming hashcode is always 128 chars length
+});
+
+export type createCheckParam = z.infer<typeof createCheckParamsSchema>;

package/src/server/schemas/getBaseline.shema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const RequiredIdentOptionsSchema = z.object({
+    name: z.string().min(1),
+    viewport: z.string().min(3),
+    browserName: z.string().min(1),
+    os: z.string().min(1),
+    app: z.string().min(1),
+    branch: z.string().min(1),
+})
+
+export type RequiredIdentOptions = z.infer<typeof RequiredIdentOptionsSchema>;

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

@@ -0,0 +1,23 @@
+/* eslint-disable valid-jsdoc */
+const { App } = require('../models');
+
+const $this = this;
+$this.logMeta = {
+    scope: 'logs_service',
+    msgType: 'LOG',
+};
+
+/**
+ * Query for users
+ * @param {Object} filter - Mongo filter
+ * @param {Object} options - Query options
+ * @param {string} [options.sortBy] - Sort option in the format: sortField:(desc|asc)
+ * @param {number} [options.limit] - Maximum number of results per page (default = 10)
+ * @param {number} [options.page] - Current page (default = 1)
+ * @returns {Promise<QueryResult>}
+ */
+const get = async (filter, options) => App.paginate(filter, options);
+
+module.exports = {
+    get,
+};