@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/dist/tasks/lib/index.js

@@ -0,0 +1,717 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tasks/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  App: () => App_model_default,
+  Baseline: () => Baseline_model_default,
+  Check: () => Check_model_default,
+  Log: () => Log_model_default,
+  Run: () => Run_model_default,
+  Snapshot: () => Snapshot_model_default,
+  Suite: () => Suite_model_default,
+  Test: () => Test_model_default,
+  User: () => User_model_default
+});
+module.exports = __toCommonJS(lib_exports);
+
+// src/server/models/Check.model.ts
+var import_mongoose = __toESM(require("mongoose"));
+
+// src/server/models/plugins/paginate.plugin.ts
+var paginate = (schema) => {
+  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.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) => {
+        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,
+        timestamp: Number(Date.now() + String(process.hrtime()[1]).slice(3, 6))
+      };
+      return Promise.resolve(result);
+    });
+  };
+};
+var paginate_plugin_default = paginate;
+
+// src/server/models/plugins/toJSON.plugin.ts
+var deleteAtPath = (obj, path, index) => {
+  if (index === path.length - 1) {
+    delete obj[path[index]];
+    return;
+  }
+  deleteAtPath(obj[path[index]], path, index + 1);
+};
+var 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.__v;
+      delete ret.createdAt;
+      delete ret.updatedAt;
+      if (transform) {
+        return transform(doc, ret, options);
+      }
+    }
+  });
+};
+var toJSON_plugin_default = toJSON;
+
+// src/server/models/plugins/paginateDistinct.plugin.ts
+var import_bson = require("bson");
+var paginateDistinct = (schema) => {
+  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.toString(), 10) >= 0 ? parseInt(options.limit.toString(), 10) : 10;
+    limit = limit === 0 ? 9007199254740991 : limit;
+    const page = options.page && parseInt(options.page.toString(), 10) > 0 ? parseInt(options.page.toString(), 10) : 1;
+    const skip = (page - 1) * limit;
+    const groupAggregateObj = { $group: { _id: `$${options.field}` } };
+    const documentsCount = (await this.aggregate([groupAggregateObj]).exec()).length;
+    const aggregateArr = [
+      { $match: import_bson.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: (/* @__PURE__ */ new Date()).getTime()
+      };
+      return Promise.resolve(result);
+    });
+  };
+};
+var paginateDistinct_plugin_default = paginateDistinct;
+
+// src/server/models/Check.model.ts
+var CheckSchema = new import_mongoose.Schema({
+  name: {
+    type: String,
+    required: [true, 'CheckSchema: The "name" field must be required']
+  },
+  test: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSTest",
+    required: [true, 'CheckSchema: The "test" field must be required']
+  },
+  suite: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSSuite",
+    required: [true, 'CheckSchema: The "suite" field must be required']
+  },
+  app: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSApp",
+    required: [true, 'CheckSchema: The "app" field must be required']
+  },
+  branch: {
+    type: String
+  },
+  realBaselineId: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSBaseline"
+  },
+  baselineId: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSSnapshot"
+  },
+  actualSnapshotId: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSSnapshot"
+  },
+  diffId: {
+    type: import_mongoose.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: import_mongoose.Schema.Types.ObjectId
+  },
+  markedAs: {
+    type: String,
+    enum: ["bug", "accepted"]
+  },
+  markedDate: {
+    type: Date
+  },
+  markedById: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSUser"
+  },
+  markedByUsername: {
+    type: String
+  },
+  markedBugComment: {
+    type: String
+  },
+  creatorId: {
+    type: import_mongoose.Schema.Types.ObjectId,
+    ref: "VRSUser"
+  },
+  creatorUsername: {
+    type: String
+  },
+  failReasons: {
+    type: [String]
+  },
+  vOffset: {
+    type: String
+  },
+  topStablePixels: {
+    type: String
+  },
+  meta: {
+    type: Object
+  }
+});
+CheckSchema.plugin(toJSON_plugin_default);
+CheckSchema.plugin(paginate_plugin_default);
+var Check = import_mongoose.default.model("VRSCheck", CheckSchema);
+var Check_model_default = Check;
+
+// src/server/models/Log.model.ts
+var import_mongoose2 = __toESM(require("mongoose"));
+var LogSchema = new import_mongoose2.Schema({
+  timestamp: {
+    type: Date
+  },
+  level: {
+    type: String
+  },
+  message: {
+    type: String
+  },
+  meta: {
+    type: Object
+  },
+  hostname: {
+    type: Object
+  }
+});
+LogSchema.plugin(toJSON_plugin_default);
+LogSchema.plugin(paginate_plugin_default);
+var Log = import_mongoose2.default.model("VRSLog", LogSchema);
+var Log_model_default = Log;
+
+// src/server/models/App.model.ts
+var import_mongoose3 = __toESM(require("mongoose"));
+var AppSchema = new import_mongoose3.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_plugin_default);
+AppSchema.plugin(toJSON_plugin_default);
+var App = import_mongoose3.default.model("VRSApp", AppSchema);
+var App_model_default = App;
+
+// src/server/models/Snapshot.model.ts
+var import_mongoose4 = __toESM(require("mongoose"));
+var SnapshotSchema = new import_mongoose4.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_plugin_default);
+SnapshotSchema.plugin(paginate_plugin_default);
+var Snapshot = import_mongoose4.default.model("VRSSnapshot", SnapshotSchema);
+var Snapshot_model_default = Snapshot;
+
+// src/server/models/AppSettings.model.ts
+var import_mongoose5 = __toESM(require("mongoose"));
+var AppSettingsSchema = new import_mongoose5.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: import_mongoose5.Schema.Types.Mixed,
+    required: [true, 'AppSettingsSchema: The "value" field must be required']
+  },
+  env_variable: {
+    type: String
+  },
+  enabled: {
+    type: Boolean
+  }
+});
+AppSettingsSchema.plugin(toJSON_plugin_default);
+var AppSettings = import_mongoose5.default.model("VRSAppSettings", AppSettingsSchema);
+
+// src/server/models/Suite.model.ts
+var import_mongoose6 = __toESM(require("mongoose"));
+var SuiteSchema = new import_mongoose6.Schema({
+  name: {
+    type: String,
+    default: "Others",
+    unique: true,
+    required: [true, 'SuiteSchema: The "name" field must be required']
+  },
+  tags: {
+    type: [String]
+  },
+  app: {
+    type: import_mongoose6.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_plugin_default);
+SuiteSchema.plugin(toJSON_plugin_default);
+var Suite = import_mongoose6.default.model("VRSSuite", SuiteSchema);
+var Suite_model_default = Suite;
+
+// src/server/models/Run.model.ts
+var import_mongoose7 = __toESM(require("mongoose"));
+var RunSchema = new import_mongoose7.Schema({
+  name: {
+    type: String,
+    required: [true, 'RunSchema: The "name" field must be required']
+  },
+  app: {
+    type: import_mongoose7.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_plugin_default);
+RunSchema.plugin(toJSON_plugin_default);
+var Run = import_mongoose7.default.model("VRSRun", RunSchema);
+var Run_model_default = Run;
+
+// src/server/models/User.model.ts
+var import_mongoose8 = __toESM(require("mongoose"));
+var import_passport_local_mongoose = __toESM(require("passport-local-mongoose"));
+var UserSchema = new import_mongoose8.Schema({
+  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_plugin_default);
+UserSchema.plugin(paginate_plugin_default);
+UserSchema.plugin(import_passport_local_mongoose.default, { hashField: "password" });
+var User = import_mongoose8.default.model("VRSUser", UserSchema);
+var User_model_default = User;
+
+// src/server/models/Baseline.model.ts
+var import_mongoose9 = __toESM(require("mongoose"));
+var BaselineSchema = new import_mongoose9.Schema({
+  snapshootId: {
+    type: import_mongoose9.Schema.Types.ObjectId
+  },
+  name: {
+    type: String,
+    required: [true, 'VRSBaselineSchema: The "name" field must be required']
+  },
+  app: {
+    type: import_mongoose9.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: import_mongoose9.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_plugin_default);
+BaselineSchema.plugin(paginate_plugin_default);
+var Baseline = import_mongoose9.default.model("VRSBaseline", BaselineSchema);
+var Baseline_model_default = Baseline;
+
+// src/server/models/Test.model.ts
+var import_mongoose10 = __toESM(require("mongoose"));
+var TestSchema = new import_mongoose10.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: import_mongoose10.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: import_mongoose10.default.Schema.Types.ObjectId,
+        ref: "VRSCheck"
+      }
+    ],
+    suite: {
+      type: import_mongoose10.Schema.Types.ObjectId,
+      ref: "VRSSuite"
+    },
+    run: {
+      type: import_mongoose10.Schema.Types.ObjectId,
+      ref: "VRSRun"
+    },
+    markedAs: {
+      type: String,
+      enum: ["Bug", "Accepted", "Unaccepted", "Partially"]
+    },
+    creatorId: {
+      type: import_mongoose10.Schema.Types.ObjectId,
+      ref: "VRSUser"
+    },
+    creatorUsername: {
+      type: String
+    },
+    meta: {
+      type: Object
+    }
+  },
+  { strictQuery: true }
+);
+TestSchema.plugin(toJSON_plugin_default);
+TestSchema.plugin(paginate_plugin_default);
+TestSchema.plugin(paginateDistinct_plugin_default);
+var Test = import_mongoose10.default.model("VRSTest", TestSchema);
+var Test_model_default = Test;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  App,
+  Baseline,
+  Check,
+  Log,
+  Run,
+  Snapshot,
+  Suite,
+  Test,
+  User
+});
+//# sourceMappingURL=index.js.map