@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/dist/src/server/models/index.js

@@ -1,508 +0,0 @@
-"use strict";
-/* eslint-disable valid-jsdoc,func-names */
-const passportLocalMongoose = require('passport-local-mongoose');
-const mongoose = require('mongoose');
-const { toJSON, paginate, paginateDistinct } = require('./plugins');
-const { Schema } = mongoose;
-const SnapshotSchema = new Schema({
-    name: {
-        type: String,
-        required: 'SnapshotSchema: the name of the snapshot entity is empty',
-    },
-    path: {
-        type: String,
-    },
-    filename: {
-        type: String,
-    },
-    imghash: {
-        type: String,
-        required: 'SnapshotSchema: the image hash of the snapshot entity is empty',
-    },
-    createdDate: {
-        type: Date,
-        default: Date.now,
-    },
-    vOffset: {
-        type: Number,
-    },
-    hOffset: {
-        type: Number,
-    },
-});
-const CheckSchema = new Schema({
-    name: {
-        type: String,
-        required: 'CheckSchema: the name of the check entity is empty',
-    },
-    test: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSTest',
-        required: 'CheckSchema: the test name of the check entity is empty',
-    },
-    suite: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSSuite',
-        required: 'CheckSchema: the app field is empty',
-    },
-    app: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSApp',
-        required: 'CheckSchema: the app field is empty',
-    },
-    branch: {
-        type: String,
-    },
-    realBaselineId: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSBaseline',
-    },
-    baselineId: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSSnapshot',
-    },
-    actualSnapshotId: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSSnapshot',
-    },
-    diffId: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSSnapshot',
-    },
-    createdDate: {
-        type: Date,
-        required: true,
-        default: Date.now,
-    },
-    updatedDate: {
-        type: Date,
-    },
-    status: {
-        type: [{
-                type: String,
-                enum: {
-                    values: ['new', 'pending', 'approved', 'running', 'passed', 'failed', 'aborted'],
-                    message: 'status is required',
-                },
-            }],
-        default: 'new',
-    },
-    browserName: {
-        type: String,
-    },
-    browserVersion: {
-        type: String,
-    },
-    browserFullVersion: {
-        type: String,
-    },
-    viewport: {
-        type: String,
-    },
-    os: {
-        type: String,
-    },
-    domDump: {
-        type: String,
-    },
-    result: {
-        type: String,
-        default: '{}',
-    },
-    run: {
-        type: Schema.Types.ObjectId,
-    },
-    markedAs: {
-        type: String,
-        enum: ['bug', 'accepted'],
-    },
-    markedDate: {
-        type: Date,
-    },
-    markedById: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSUser',
-    },
-    markedByUsername: {
-        type: String,
-    },
-    markedBugComment: {
-        type: String,
-    },
-    creatorId: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSUser',
-    },
-    creatorUsername: {
-        type: String,
-    },
-    failReasons: {
-        type: [String],
-    },
-    vOffset: {
-        type: String,
-    },
-    topStablePixels: {
-        type: String,
-    },
-    meta: {
-        type: Object,
-    },
-});
-const BaselineSchema = new Schema({
-    snapshootId: Schema.Types.ObjectId,
-    name: {
-        type: String,
-        required: 'VRSBaselineSchema: the name of the snapshoot entity is empty',
-    },
-    app: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSApp',
-        required: 'VRSBaselineSchema: the app field is empty',
-    },
-    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', 'less', 'colors', 'alpha'],
-        enum: ['antialiasing', 'nothing', 'colors'],
-    },
-    meta: {
-        type: Object,
-    },
-});
-const TestSchema = new Schema({
-    name: {
-        type: String,
-        required: 'TestSchema: the test name is empty',
-    },
-    description: {
-        type: String,
-    },
-    status: {
-        type: String,
-    },
-    browserName: {
-        type: String,
-    },
-    browserVersion: {
-        type: String,
-    },
-    branch: {
-        type: String,
-    },
-    tags: {
-        type: [String],
-    },
-    viewport: {
-        type: String,
-    },
-    // after handle all checks inside the test
-    calculatedViewport: {
-        type: String,
-    },
-    os: {
-        type: String,
-    },
-    app: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSApp',
-        required: 'TestSchema: the app field is empty',
-    },
-    blinking: {
-        type: Number,
-        default: 0,
-    },
-    updatedDate: {
-        type: Date,
-    },
-    startDate: {
-        type: Date,
-    },
-    checks: [
-        {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'VRSCheck',
-        },
-    ],
-    suite: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSSuite',
-    },
-    run: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSRun',
-    },
-    markedAs: {
-        type: String,
-        enum: ['Bug', 'Accepted', 'Unaccepted', 'Partially'],
-    },
-    creatorId: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSUser',
-    },
-    creatorUsername: {
-        type: String,
-    },
-    meta: {
-        type: Object,
-    },
-}, { strictQuery: true }); // remove filters that not exist in schema
-const SuiteSchema = new Schema({
-    name: {
-        type: String,
-        default: 'Others',
-        unique: true,
-        required: 'SuiteSchema: the suite name is empty',
-    },
-    tags: {
-        type: [String],
-    },
-    app: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSApp',
-        required: 'SuiteSchema: the app field is empty',
-    },
-    description: {
-        type: String,
-    },
-    updatedDate: {
-        type: Date,
-        default: Date.now,
-    },
-    createdDate: {
-        type: Date,
-    },
-    meta: {
-        type: Object,
-    },
-});
-const RunSchema = new Schema({
-    name: {
-        type: String,
-        required: 'RunSchema: the run name cannot be empty',
-    },
-    app: {
-        type: Schema.Types.ObjectId,
-        ref: 'VRSApp',
-        required: 'RunSchema: the app field is empty',
-    },
-    ident: {
-        type: String,
-        unique: true,
-        required: 'RunSchema: the run ident run cannot be empty',
-    },
-    description: {
-        type: String,
-    },
-    updatedDate: {
-        type: Date,
-        default: Date.now,
-    },
-    createdDate: {
-        type: Date,
-    },
-    parameters: {
-        type: [String],
-    },
-    meta: {
-        type: Object,
-    },
-});
-const LogSchema = new Schema({
-    timestamp: {
-        type: Date,
-    },
-    level: {
-        type: String,
-    },
-    message: {
-        type: String,
-    },
-    meta: {
-        type: Object,
-    },
-    hostname: {
-        type: Object,
-    },
-});
-// this is the Projects Schema `VRSAppSchema` name is for historical reason
-const AppSchema = new Schema({
-    name: {
-        type: String,
-        default: 'Others',
-        unique: true,
-        required: 'AppSchema: the Application name is empty',
-    },
-    description: {
-        type: String,
-    },
-    version: {
-        type: String,
-    },
-    updatedDate: {
-        type: Date,
-    },
-    createdDate: {
-        type: Date,
-    },
-    meta: {
-        type: Object,
-    },
-});
-const UserSchema = new Schema({
-    username: {
-        type: String,
-        unique: true,
-        required: 'UserSchema: the username name is empty',
-    },
-    firstName: {
-        type: String,
-        required: 'UserSchema: the firstName name is empty',
-    },
-    lastName: {
-        type: String,
-        required: 'UserSchema: the lastName name is empty',
-    },
-    role: {
-        type: String,
-        enum: {
-            values: ['admin', 'reviewer', 'user'],
-            message: 'UserSchema: role is required',
-            required: 'UserSchema: role is required',
-        },
-    },
-    password: {
-        type: String,
-    },
-    token: {
-        type: String,
-    },
-    apiKey: {
-        type: String,
-    },
-    createdDate: {
-        type: Date,
-    },
-    updatedDate: {
-        type: Date,
-    },
-    expiration: {
-        type: Date,
-    },
-    meta: {
-        type: Object,
-    },
-});
-const AppSettingsSchema = new Schema({
-    name: {
-        type: String,
-        unique: true,
-        required: 'AppSettingsSchema: the name is empty',
-    },
-    label: {
-        type: String,
-        required: 'AppSettingsSchema: the label is empty',
-    },
-    description: {
-        type: String,
-    },
-    type: {
-        type: String,
-        required: 'AppSettingsSchema: the type is empty',
-    },
-    value: {
-        type: Schema.Types.Mixed,
-        required: 'AppSettingsSchema: the value is empty',
-    },
-    env_variable: {
-        type: String,
-    },
-    enabled: {
-        type: Boolean,
-    },
-});
-AppSettingsSchema.plugin(toJSON);
-LogSchema.plugin(toJSON);
-LogSchema.plugin(paginate);
-UserSchema.plugin(toJSON);
-UserSchema.plugin(paginate);
-RunSchema.plugin(paginate);
-RunSchema.plugin(toJSON);
-SuiteSchema.plugin(paginate);
-SuiteSchema.plugin(toJSON);
-AppSchema.plugin(paginate);
-AppSchema.plugin(toJSON);
-BaselineSchema.plugin(toJSON);
-BaselineSchema.plugin(paginate);
-SnapshotSchema.plugin(toJSON);
-SnapshotSchema.plugin(paginate);
-CheckSchema.plugin(toJSON);
-CheckSchema.plugin(paginate);
-TestSchema.plugin(toJSON);
-TestSchema.plugin(paginate);
-TestSchema.plugin(paginateDistinct);
-/**
- * Check if email is taken
- * @param {string} username - The user's email
- * @param {ObjectId} [excludeUserId] - The id of the user to be excluded
- * @returns {Promise<boolean>}
- */
-UserSchema.statics.isEmailTaken = async function (username, excludeUserId) {
-    const user = await this.findOne({ username, _id: { $ne: excludeUserId } });
-    return !!user;
-};
-UserSchema.plugin(passportLocalMongoose, { hashField: 'password' });
-const Snapshot = mongoose.model('VRSSnapshot', SnapshotSchema);
-const Check = mongoose.model('VRSCheck', CheckSchema);
-const Test = mongoose.model('VRSTest', TestSchema);
-const Log = mongoose.model('VRSLog', LogSchema);
-const Suite = mongoose.model('VRSSuite', SuiteSchema);
-const App = mongoose.model('VRSApp', AppSchema);
-const Run = mongoose.model('VRSRun', RunSchema);
-const User = mongoose.model('VRSUser', UserSchema);
-const Baseline = mongoose.model('VRSBaseline', BaselineSchema);
-const AppSettings = mongoose.model('VRSAppSettings', AppSettingsSchema);
-module.exports = { Snapshot, Check, Test, Log, Suite, App, Run, User, Baseline, AppSettings };

package/dist/src/server/models/plugins/index.js

@@ -1,4 +0,0 @@
-"use strict";
-module.exports.toJSON = require('./toJSON.plugin');
-module.exports.paginate = require('./paginate.plugin');
-module.exports.paginateDistinct = require('./paginateDistinct.plugin');

package/dist/src/server/models/plugins/paginate.plugin.js

@@ -1,76 +0,0 @@
-"use strict";
-/* eslint-disable no-param-reassign, valid-jsdoc */
-const paginate = (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.paginate = async function (filter, options) {
-        let sort = '';
-        if (options.sortBy) {
-            const sortingCriteria = [];
-            options.sortBy.split(',')
-                .forEach((sortOption) => {
-                const [key, order] = sortOption.split(':');
-                sortingCriteria.push((order === 'desc' ? '-' : '') + key);
-            });
-            sort = sortingCriteria.join(' ');
-        }
-        else {
-            sort = { _id: -1 };
-        }
-        const limit = options.limit && parseInt(options.limit, 10) >= 0 ? parseInt(options.limit, 10) : 10;
-        const page = options.page && parseInt(options.page, 10) > 0 ? parseInt(options.page, 10) : 1;
-        const skip = (page - 1) * limit;
-        const countPromise = this.countDocuments(filter)
-            .exec();
-        let docsPromise = this.find(filter)
-            .sort(sort)
-            .skip(skip)
-            .limit(limit);
-        if (options.populate) {
-            options.populate.split(',')
-                .forEach((populateOption) => {
-                docsPromise = docsPromise.populate(populateOption
-                    .split('.')
-                    .reverse()
-                    .reduce((a, b) => ({ path: b, populate: a })));
-            });
-        }
-        docsPromise = docsPromise.exec();
-        return Promise.all([countPromise, docsPromise])
-            .then((values) => {
-            const [totalResults, results] = values;
-            const totalPages = Math.ceil(totalResults / limit);
-            const result = {
-                results,
-                page,
-                limit,
-                totalPages,
-                totalResults,
-                // microseconds
-                timestamp: Number(Date.now() + String(process.hrtime()[1])
-                    .slice(3, 6)),
-            };
-            return Promise.resolve(result);
-        });
-    };
-};
-module.exports = paginate;

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

@@ -1,76 +0,0 @@
-"use strict";
-/* 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/dist/src/server/models/plugins/toJSON.plugin.js

@@ -1,39 +0,0 @@
-"use strict";
-/* 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;