@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

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

@@ -0,0 +1,166 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface CheckDocument extends Document {
+    name: string;
+    test: Schema.Types.ObjectId;
+    suite: Schema.Types.ObjectId;
+    app: Schema.Types.ObjectId;
+    branch?: string;
+    realBaselineId?: Schema.Types.ObjectId;
+    baselineId?: Schema.Types.ObjectId;
+    actualSnapshotId?: Schema.Types.ObjectId;
+    diffId?: Schema.Types.ObjectId;
+    createdDate: Date;
+    updatedDate?: Date;
+    // status: ['new', 'pending', 'approved', 'running', 'passed', 'failed', 'aborted'];
+    status: ('new' | 'pending' | 'approved' | 'running' | 'passed' | 'failed' | 'aborted' | 'blinking')[];
+    browserName?: string;
+    browserVersion?: string;
+    browserFullVersion?: string;
+    viewport?: string;
+    os?: string;
+    domDump?: string;
+    result?: string;
+    run?: Schema.Types.ObjectId;
+    markedAs?: 'bug' | 'accepted';
+    markedDate?: Date;
+    markedById?: Schema.Types.ObjectId;
+    markedByUsername?: string;
+    markedBugComment?: string;
+    creatorId?: Schema.Types.ObjectId;
+    creatorUsername?: string;
+    failReasons?: string[];
+    vOffset?: string;
+    topStablePixels?: string;
+    meta?: Record<string, unknown>;
+}
+
+// const CheckSchema: Schema<CheckDocument> = new Schema({
+const CheckSchema = new Schema<CheckDocument>({
+    name: {
+        type: String,
+        required: [true, 'CheckSchema: The "name" field must be required'],
+    },
+    test: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSTest',
+        required: [true, 'CheckSchema: The "test" field must be required'],
+    },
+    suite: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSSuite',
+        required: [true, 'CheckSchema: The "suite" field must be required'],
+    },
+    app: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSApp',
+        required: [true, 'CheckSchema: The "app" field must be required'],
+    },
+    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,
+    },
+});
+
+CheckSchema.plugin(toJSON);
+CheckSchema.plugin(paginate);
+
+const Check: Model<CheckDocument> = mongoose.model<CheckDocument>('VRSCheck', CheckSchema);
+export default Check as PluginExtededModel<CheckDocument>;
+

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

@@ -0,0 +1,36 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface LogDocument extends Document {
+    timestamp?: Date;
+    level?: string;
+    message?: string;
+    meta?: Record<string, unknown>;
+    hostname?: string;
+}
+
+const LogSchema: Schema<LogDocument> = new Schema({
+    timestamp: {
+        type: Date,
+    },
+    level: {
+        type: String,
+    },
+    message: {
+        type: String,
+    },
+    meta: {
+        type: Object,
+    },
+    hostname: {
+        type: Object,
+    },
+});
+
+LogSchema.plugin(toJSON);
+LogSchema.plugin(paginate);
+
+const Log: Model<LogDocument> = mongoose.model<LogDocument>('VRSLog', LogSchema);
+export default Log as PluginExtededModel<LogDocument>;
+

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

@@ -0,0 +1,55 @@
+
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface RunDocument extends Document {
+    name: string;
+    app: Schema.Types.ObjectId;
+    ident: string;
+    description?: string;
+    updatedDate?: Date;
+    createdDate?: Date;
+    parameters?: string[];
+    meta?: Record<string, unknown>;
+}
+
+const RunSchema: Schema<RunDocument> = new Schema({
+    name: {
+        type: String,
+        required: [true, 'RunSchema: The "name" field must be required'],
+    },
+    app: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSApp',
+        required: [true, 'RunSchema: The "app" field must be required'],
+    },
+    ident: {
+        type: String,
+        unique: true,
+        required: [true, 'RunSchema: The "ident" field must be required'],
+    },
+    description: {
+        type: String,
+    },
+    updatedDate: {
+        type: Date,
+        default: Date.now,
+    },
+    createdDate: {
+        type: Date,
+    },
+    parameters: {
+        type: [String],
+    },
+    meta: {
+        type: Object,
+    },
+});
+
+RunSchema.plugin(paginate);
+RunSchema.plugin(toJSON);
+
+const Run: Model<RunDocument> = mongoose.model<RunDocument>('VRSRun', RunSchema);
+export default Run as PluginExtededModel<RunDocument>;
+

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

@@ -0,0 +1,47 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface SnapshotDocument extends Document {
+    name: string;
+    path?: string;
+    filename?: string;
+    imghash: string;
+    createdDate?: Date;
+    vOffset?: number;
+    hOffset?: number;
+}
+
+const SnapshotSchema: Schema<SnapshotDocument> = new Schema({
+    name: {
+        type: String,
+        required: [true, 'SnapshotSchema: The "name" field must be required'],
+    },
+    path: {
+        type: String,
+    },
+    filename: {
+        type: String,
+    },
+    imghash: {
+        type: String,
+        required: [true, 'SnapshotSchema: The "imghash" field must be required'],
+    },
+    createdDate: {
+        type: Date,
+        default: Date.now,
+    },
+    vOffset: {
+        type: Number,
+    },
+    hOffset: {
+        type: Number,
+    },
+});
+
+SnapshotSchema.plugin(toJSON);
+SnapshotSchema.plugin(paginate);
+
+const Snapshot: Model<SnapshotDocument> = mongoose.model<SnapshotDocument>('VRSSnapshot', SnapshotSchema);
+
+export default Snapshot as PluginExtededModel<SnapshotDocument>;

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

@@ -0,0 +1,50 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface SuiteDocument extends Document {
+    name: string;
+    tags?: string[];
+    app: Schema.Types.ObjectId;
+    description?: string;
+    updatedDate?: Date;
+    createdDate?: Date;
+    meta?: Record<string, unknown>;
+}
+
+const SuiteSchema: Schema<SuiteDocument> = new Schema({
+    name: {
+        type: String,
+        default: 'Others',
+        unique: true,
+        required: [true, 'SuiteSchema: The "name" field must be required'],
+    },
+    tags: {
+        type: [String],
+    },
+    app: {
+        type: Schema.Types.ObjectId,
+        ref: 'VRSApp',
+        required: [true, 'SuiteSchema: The "app" field must be required'],
+    },
+    description: {
+        type: String,
+    },
+    updatedDate: {
+        type: Date,
+        default: Date.now,
+    },
+    createdDate: {
+        type: Date,
+    },
+    meta: {
+        type: Object,
+    },
+});
+
+SuiteSchema.plugin(paginate);
+SuiteSchema.plugin(toJSON);
+
+const Suite: Model<SuiteDocument> = mongoose.model<SuiteDocument>('VRSSuite', SuiteSchema);
+
+export default Suite as PluginExtededModel<SuiteDocument>;

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

@@ -0,0 +1,117 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate, paginateDistinct } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export interface TestDocument extends Document {
+    name: string;
+    description?: string;
+    status?: string;
+    browserName: string;
+    browserVersion: string;
+    branch?: string;
+    tags?: string[];
+    viewport: string;
+    calculatedViewport?: string;
+    // calculatedStatus?: string;
+    os: string;
+    app: Schema.Types.ObjectId;
+    blinking?: number;
+    updatedDate: Date;
+    startDate: Date;
+    checks?: Schema.Types.ObjectId[];
+    suite?: Schema.Types.ObjectId;
+    run: Schema.Types.ObjectId;
+    markedAs?: 'Bug' | 'Accepted' | 'Unaccepted' | 'Partially';
+    creatorId?: Schema.Types.ObjectId;
+    creatorUsername?: string;
+    meta?: Record<string, unknown>;
+}
+
+const TestSchema: Schema<TestDocument> = 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,
+        },
+        calculatedViewport: {
+            type: String,
+        },
+        os: {
+            type: String,
+        },
+        app: {
+            type: Schema.Types.ObjectId,
+            ref: 'VRSApp',
+            required: [true, 'TestSchema: The "app" field must be required'],
+
+        },
+        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 }
+);
+
+TestSchema.plugin(toJSON);
+TestSchema.plugin(paginate);
+TestSchema.plugin(paginateDistinct);
+
+const Test: Model<TestDocument> = mongoose.model<TestDocument>('VRSTest', TestSchema);
+
+export default Test as PluginExtededModel<TestDocument>;

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

@@ -0,0 +1,77 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import passportLocalMongoose from 'passport-local-mongoose';
+import { toJSON, paginate } from './plugins';
+import { PluginExtededModel } from './plugins/utils';
+
+export type UserRole = 'admin' | 'reviewer' | 'user';
+
+export interface UserDocument extends Document {
+    username: string;
+    firstName: string;
+    lastName: string;
+    role: UserRole;
+    password?: string;
+    token?: string;
+    apiKey?: string;
+    createdDate?: Date;
+    updatedDate?: Date;
+    expiration?: Date;
+    meta?: Record<string, unknown>;
+    isEmailTaken: (username: string) => Promise<boolean>;
+    setPassword: (password: string) => Promise<UserDocument>;
+}
+
+const UserSchema = new Schema<UserDocument>({
+    username: {
+        type: String,
+        unique: true,
+        required: [true, 'UserSchema: The "username" field must be required'],
+    },
+    firstName: {
+        type: String,
+        required: [true, 'UserSchema: The "firstName" field must be required'],
+    },
+    lastName: {
+        type: String,
+        required: [true, 'UserSchema: The "lastName" field must be required'],
+    },
+    role: {
+        type: String,
+        enum: ['admin', 'reviewer', 'user'],
+        required: [true, 'UserSchema: The "role" field must be required'],
+    },
+    password: {
+        type: String,
+    },
+    token: {
+        type: String,
+    },
+    apiKey: {
+        type: String,
+    },
+    createdDate: {
+        type: Date,
+    },
+    updatedDate: {
+        type: Date,
+    },
+    expiration: {
+        type: Date,
+    },
+    meta: {
+        type: Object,
+    },
+});
+
+UserSchema.statics.isEmailTaken = async function (username, excludeUserId) {
+    const user = await this.findOne({ username, _id: { $ne: excludeUserId } });
+    return !!user;
+};
+
+UserSchema.plugin(toJSON);
+UserSchema.plugin(paginate);
+UserSchema.plugin(passportLocalMongoose, { hashField: 'password' });
+
+const User: Model<UserDocument> = mongoose.model<UserDocument>('VRSUser', UserSchema);
+
+export default User as PluginExtededModel<UserDocument>;

package/src/server/models/index.ts

@@ -0,0 +1,11 @@
+export { default as Check } from './Check.model';
+export { CheckDocument } from './Check.model';
+export { default as Log } from './Log.model';
+export { default as App } from './App.model';
+export { default as Snapshot } from './Snapshot.model';
+export { default as AppSettings } from './AppSettings.model';
+export { default as Suite } from './Suite.model';
+export { default as Run } from './Run.model';
+export { default as User } from './User.model';
+export { default as Baseline } from './Baseline.model';
+export { default as Test } from './Test.model';

package/src/server/models/plugins/index.ts

@@ -0,0 +1,3 @@
+export { default as paginate } from './paginate.plugin';
+export { default as toJSON } from './toJSON.plugin';
+export { default as paginateDistinct } from './paginateDistinct.plugin';

package/src/server/models/plugins/paginate.plugin.ts

@@ -0,0 +1,74 @@
+import { Schema, Document, FilterQuery } from 'mongoose';
+import { PaginateOptions, QueryResult } from './utils';
+
+const paginate = (schema: Schema) => {
+  /**
+   * 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>}
+   */
+  schema.statics.paginate = async function (filter: FilterQuery<unknown>, options: PaginateOptions): Promise<QueryResult> {
+    let sort: string | object;
+    if (options.sortBy) {
+      const sortingCriteria: string[] = [];
+      options.sortBy.split(',')
+        .forEach((sortOption: string) => {
+          const [key, order] = sortOption.split(':');
+          sortingCriteria.push((order === 'desc' ? '-' : '') + key);
+        });
+      sort = sortingCriteria.join(' ');
+    } else {
+      sort = { _id: -1 };
+    }
+
+    const limit = options.limit && parseInt(options.limit.toString(), 10) >= 0 ? parseInt(options.limit.toString(), 10) : 10;
+    const page = options.page && parseInt(options.page.toString(), 10) > 0 ? parseInt(options.page.toString(), 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: string) => {
+          docsPromise = docsPromise.populate(
+            populateOption
+              .split('.')
+              .reverse()
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              .reduce((a, b) => ({ path: b, populate: a }))
+          );
+        });
+    }
+
+    docsPromise = docsPromise.exec();
+
+    return Promise.all([countPromise, docsPromise])
+      .then((values: [number, Document[]]) => {
+        const [totalResults, results] = values;
+        const totalPages = Math.ceil(totalResults / limit);
+        const result: QueryResult = {
+          results,
+          page,
+          limit,
+          totalPages,
+          totalResults,
+          timestamp: Number(Date.now() + String(process.hrtime()[1]).slice(3, 6)),
+        };
+        return Promise.resolve(result);
+      });
+  };
+};
+
+export default paginate;