@syngrisi/syngrisi
Version:
Syngrisi - Visual Testing Tool
1,275 lines (1,235 loc) • 32.5 kB
JavaScript
// src/server/utils/pick.ts
var pick = (object, keys) => {
return keys.reduce((obj, key) => {
if (object && Object.prototype.hasOwnProperty.call(object, key)) {
if (object[key] !== void 0) obj[key] = object[key];
}
return obj;
}, {});
};
var pick_default = pick;
// src/server/utils/isJSON.ts
var isJSON = (text) => {
if (!text) return false;
const isValid = /^[\],:{}\s]*$/.test(
text.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, "")
);
return isValid;
};
var isJSON_default = isJSON;
// src/server/utils/catchAsync.ts
var catchAsync = (fn) => (req, res, next) => {
Promise.resolve(fn(req, res, next)).catch((err) => {
return next(err);
});
};
var catchAsync_default = catchAsync;
// src/server/utils/dateToISO8601.ts
var dateToISO8601 = (date) => {
return new Date(new Date(date)).toISOString().split("T")[0];
};
var dateToISO8601_default = dateToISO8601;
// src/server/utils/ProgressBar.ts
var ProgressBar = class {
length;
percentLenght;
prevPercent;
currentPercent;
progressString;
constructor(length) {
this.length = length;
this.percentLenght = parseFloat((length / 100).toString());
this.prevPercent = 0;
this.currentPercent = 0;
this.progressString = "";
}
isChange(current) {
this.currentPercent = parseInt((current / this.percentLenght).toString(), 10);
if (this.prevPercent === this.currentPercent) {
return false;
}
this.prevPercent = this.currentPercent;
this.progressString += "#";
return true;
}
writeIfChange(index, count, fn, res) {
if (this.isChange(index)) {
const placeholderString = Array.from(new Array(99 - this.currentPercent)).reduce((accum) => accum += ".", "");
fn(`[${this.progressString}${placeholderString}](${index}/${count})`, res);
}
}
};
// src/server/utils/ApiError.ts
var ApiError = class extends Error {
statusCode;
isOperational;
constructor(statusCode, message, isOperational = true, stack = "") {
super(message);
this.statusCode = statusCode;
this.isOperational = isOperational;
if (stack) {
this.stack = stack;
} else {
Error.captureStackTrace(this, this.constructor);
}
}
};
var ApiError_default = ApiError;
// src/server/utils/removeEmptyProperties.ts
var removeEmptyProperties = (obj) => Object.fromEntries(
// eslint-disable-next-line @typescript-eslint/no-unused-vars
Object.entries(obj).filter(([_, v]) => v != null && v !== "")
);
// src/server/utils/deserializeIfJSON.ts
import mongoose from "mongoose";
var { EJSON } = mongoose.mongo.BSON;
var EXTENDED_JSON_KEYS = [
"$oid",
"$date",
"$numberInt",
"$numberLong",
"$numberDouble",
"$numberDecimal",
"$regularExpression",
"$binary",
"$timestamp"
];
var containsExtendedJsonMarkers = (text) => EXTENDED_JSON_KEYS.some((marker) => text.includes(`"${marker}"`));
var deserializeIfJSON = (text) => {
if (isJSON_default(text)) {
if (containsExtendedJsonMarkers(text)) {
return EJSON.parse(text) || void 0;
}
return JSON.parse(text) || void 0;
}
return text;
};
var deserializeIfJSON_default = deserializeIfJSON;
// src/server/utils/prettyCheckParams.ts
var prettyCheckParams = (result) => {
if (!result.domDump) {
return JSON.stringify(result);
}
const dump = JSON.parse(result.domDump);
const resObs = { ...result };
delete resObs.domDump;
resObs.domDump = `${JSON.stringify(dump).substr(0, 20)}... and about ${dump.length} items]`;
return JSON.stringify(resObs);
};
var prettyCheckParams_default = prettyCheckParams;
// src/server/utils/waitUntil.ts
var waitUntil = async (cb, attempts = 5, interval = 700) => {
let result = false;
let iteration = 0;
while (result === false) {
result = await cb();
await new Promise((r) => setTimeout(r, interval));
iteration += 1;
if (iteration > attempts) {
result = true;
}
}
return result;
};
// src/server/utils/imageUtils.ts
var getPngDimensions = (buffer) => {
if (buffer.length < 24) {
throw new Error("Buffer too small to be a PNG");
}
if (buffer.readUInt32BE(0) !== 2303741511 || buffer.readUInt32BE(4) !== 218765834) {
throw new Error("Invalid PNG signature");
}
const width = buffer.readUInt32BE(16);
const height = buffer.readUInt32BE(20);
return { width, height };
};
// src/server/utils/paramsGuard.ts
var paramsGuard = (params, functionName, schema) => {
const result = schema.safeParse(params);
if (result.success) {
return true;
} else {
const errorDetails = result.error.format();
throw new Error(`
Invalid '${functionName}' parameters: ${JSON.stringify(errorDetails)}
error: ${result.error.stack || result.error}
params: ${JSON.stringify(params, null, 2)}
`);
}
};
// src/server/utils/ident.ts
var ident = ["name", "viewport", "browserName", "os", "app", "branch"];
// src/server/utils/buildIdentObject.ts
var MissingIdentFieldError = class extends Error {
constructor(field) {
super(`Missing required ident field: ${field}`);
this.name = "MissingIdentFieldError";
}
};
var buildIdentObject = (params) => {
const result = {};
for (const key of ident) {
if (key in params && params[key] !== void 0) {
result[key] = params[key];
} else {
throw new MissingIdentFieldError(key);
}
}
return result;
};
// src/server/models/Check.model.ts
import mongoose2, { Schema } from "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 = [];
let primaryOrder = "desc";
options.sortBy.split(",").forEach((sortOption, index) => {
const [key, order] = sortOption.split(":");
if (index === 0) primaryOrder = order || "asc";
sortingCriteria.push((order === "desc" ? "-" : "") + key);
});
if (!sortingCriteria.some((s) => s === "_id" || s === "-_id")) {
sortingCriteria.push((primaryOrder === "desc" ? "-" : "") + "_id");
}
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 countStrategy = options.countStrategy ?? (filter && Object.keys(filter).length === 0 ? "estimated" : "exact");
const countPromise = countStrategy === "estimated" ? this.estimatedDocumentCount().exec() : 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/Check.model.ts
var CheckSchema = new Schema({
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
},
toleranceThreshold: {
type: Number,
min: 0,
max: 100
},
meta: {
type: Object
}
});
CheckSchema.plugin(toJSON_plugin_default);
CheckSchema.plugin(paginate_plugin_default);
var Check = mongoose2.model("VRSCheck", CheckSchema);
var Check_model_default = Check;
// src/server/models/Log.model.ts
import mongoose3, { Schema as Schema2 } from "mongoose";
var LogSchema = new Schema2({
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 = mongoose3.model("VRSLog", LogSchema);
// src/server/models/App.model.ts
import mongoose4, { Schema as Schema3 } from "mongoose";
var AppSchema = new Schema3({
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 = mongoose4.model("VRSApp", AppSchema);
// src/server/models/Snapshot.model.ts
import mongoose5, { Schema as Schema4 } from "mongoose";
var SnapshotSchema = new Schema4({
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 = mongoose5.model("VRSSnapshot", SnapshotSchema);
// src/server/models/AppSettings.model.ts
import mongoose6, { Schema as Schema5 } from "mongoose";
var AppSettingsSchema = new Schema5({
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: Schema5.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 = mongoose6.model("VRSAppSettings", AppSettingsSchema);
// src/server/models/Suite.model.ts
import mongoose7, { Schema as Schema6 } from "mongoose";
var SuiteSchema = new Schema6({
name: {
type: String,
default: "Others",
unique: true,
required: [true, 'SuiteSchema: The "name" field must be required']
},
tags: {
type: [String]
},
app: {
type: Schema6.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 = mongoose7.model("VRSSuite", SuiteSchema);
// src/server/models/Run.model.ts
import mongoose8, { Schema as Schema7 } from "mongoose";
var RunSchema = new Schema7({
name: {
type: String,
required: [true, 'RunSchema: The "name" field must be required']
},
app: {
type: Schema7.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 = mongoose8.model("VRSRun", RunSchema);
// src/server/models/User.model.ts
import mongoose9, { Schema as Schema8 } from "mongoose";
import plm from "passport-local-mongoose";
var passportLocalMongoose = plm.default || plm;
var UserSchema = new Schema8({
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']
},
provider: {
type: String,
default: "local"
},
providerId: {
type: String
},
password: {
type: String
},
token: {
type: String
},
apiKey: {
type: String
},
authSource: {
type: String,
enum: ["local", "jwt", "ldap", "api"],
default: "local"
},
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(passportLocalMongoose, { hashField: "password" });
var User = mongoose9.model("VRSUser", UserSchema);
// src/server/models/Baseline.model.ts
import mongoose10, { Schema as Schema9 } from "mongoose";
var BaselineSchema = new Schema9({
snapshootId: {
type: Schema9.Types.ObjectId,
ref: "VRSSnapshot"
},
name: {
type: String,
required: [true, 'VRSBaselineSchema: The "name" field must be required']
},
app: {
type: Schema9.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: Schema9.Types.ObjectId,
ref: "VRSUser"
},
markedByUsername: {
type: String
},
ignoreRegions: {
type: String
},
boundRegions: {
type: String
},
matchType: {
type: String,
enum: ["antialiasing", "nothing", "colors"]
},
toleranceThreshold: {
type: Number,
default: 0,
min: 0,
max: 100
},
meta: {
type: Object
}
});
BaselineSchema.set("autoIndex", false);
BaselineSchema.plugin(toJSON_plugin_default);
BaselineSchema.plugin(paginate_plugin_default);
BaselineSchema.index({
name: 1,
app: 1,
branch: 1,
browserName: 1,
viewport: 1,
os: 1,
snapshootId: 1
}, { unique: true, name: "baseline_ident_snapshot_idx" });
var Baseline = mongoose10.model("VRSBaseline", BaselineSchema);
// src/server/models/Test.model.ts
import mongoose11, { Schema as Schema10 } from "mongoose";
var TestSchema = new Schema10(
{
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: Schema10.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: mongoose11.Schema.Types.ObjectId,
ref: "VRSCheck"
}
],
suite: {
type: Schema10.Types.ObjectId,
ref: "VRSSuite"
},
run: {
type: Schema10.Types.ObjectId,
ref: "VRSRun"
},
markedAs: {
type: String,
enum: ["Bug", "Accepted", "Unaccepted", "Partially"]
},
creatorId: {
type: Schema10.Types.ObjectId,
ref: "VRSUser"
},
creatorUsername: {
type: String
},
meta: {
type: Object
}
},
{ strictQuery: true }
);
TestSchema.plugin(toJSON_plugin_default);
TestSchema.plugin(paginate_plugin_default);
TestSchema.statics.paginateDistinct = async function(filter, options) {
let sort = { _id: -1 };
if (options.sortBy) {
sort = {};
options.sortBy.split(",").forEach((sortOption) => {
const [key, order] = sortOption.split(":");
sort[key] = order === "desc" ? -1 : 1;
});
}
let limit = options.limit && parseInt(options.limit.toString(), 10) >= 0 ? parseInt(options.limit.toString(), 10) : 10;
limit = limit === 0 ? Number.MAX_SAFE_INTEGER : 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 parsedFilter = typeof filter?.filter === "string" ? deserializeIfJSON_default(filter.filter) || {} : {};
const documentsCount = (await this.aggregate([{ $match: parsedFilter }, groupAggregateObj]).exec()).length;
const aggregatedDocs = (await this.aggregate([
{ $match: parsedFilter },
groupAggregateObj,
{ $sort: sort },
{ $skip: skip },
{ $limit: limit }
])).filter((x) => x._id).map((x) => {
const fieldValue = options.field ? x[options.field] : void 0;
if (Array.isArray(fieldValue) && fieldValue.length > 0) {
return fieldValue[0];
}
return { name: x._id };
});
const totalPages = Math.ceil(documentsCount / limit);
return {
results: aggregatedDocs,
page,
limit,
totalPages,
totalResults: documentsCount,
timestamp: Date.now()
};
};
var Test = mongoose11.model("VRSTest", TestSchema);
// src/server/models/Webhook.model.ts
import mongoose12, { Schema as Schema11 } from "mongoose";
var WebhookSchema = new Schema11({
url: {
type: String,
required: [true, 'WebhookSchema: The "url" field must be required']
},
events: {
type: [String],
default: ["check.updated", "check.created"]
},
secret: {
type: String
},
createdDate: {
type: Date,
default: Date.now
},
meta: {
type: Object
}
});
WebhookSchema.plugin(paginate_plugin_default);
WebhookSchema.plugin(toJSON_plugin_default);
var Webhook = mongoose12.model("VRSWebhook", WebhookSchema);
// src/server/models/ShareToken.model.ts
import mongoose13, { Schema as Schema12 } from "mongoose";
var ShareTokenSchema = new Schema12({
checkId: {
type: Schema12.Types.ObjectId,
ref: "VRSCheck",
required: [true, 'ShareTokenSchema: The "checkId" field is required'],
index: true
},
token: {
type: String,
required: [true, 'ShareTokenSchema: The "token" field is required'],
unique: true,
index: true
},
createdById: {
type: Schema12.Types.ObjectId,
ref: "VRSUser",
required: [true, 'ShareTokenSchema: The "createdById" field is required']
},
createdByUsername: {
type: String,
required: [true, 'ShareTokenSchema: The "createdByUsername" field is required']
},
createdDate: {
type: Date,
required: true,
default: Date.now
},
isRevoked: {
type: Boolean,
default: false
},
revokedDate: {
type: Date
},
revokedById: {
type: Schema12.Types.ObjectId,
ref: "VRSUser"
},
revokedByUsername: {
type: String
}
});
ShareTokenSchema.plugin(toJSON_plugin_default);
ShareTokenSchema.plugin(paginate_plugin_default);
var ShareToken = mongoose13.model("VRSShareToken", ShareTokenSchema);
// src/server/models/DomSnapshot.model.ts
import mongoose14, { Schema as Schema13 } from "mongoose";
var DomSnapshotSchema = new Schema13({
checkId: {
type: Schema13.Types.ObjectId,
ref: "VRSCheck",
required: [true, 'DomSnapshotSchema: The "checkId" field is required'],
index: true
},
baselineId: {
type: Schema13.Types.ObjectId,
ref: "VRSBaseline",
index: true
},
type: {
type: String,
enum: ["actual", "baseline"],
required: [true, 'DomSnapshotSchema: The "type" field is required']
},
filename: {
type: String,
required: [true, 'DomSnapshotSchema: The "filename" field is required']
},
hash: {
type: String,
required: [true, 'DomSnapshotSchema: The "hash" field is required'],
index: true
},
compressed: {
type: Boolean,
default: false
},
originalSize: {
type: Number,
required: [true, 'DomSnapshotSchema: The "originalSize" field is required']
},
compressedSize: {
type: Number
},
createdDate: {
type: Date,
default: Date.now
}
});
DomSnapshotSchema.index({ checkId: 1, type: 1 });
DomSnapshotSchema.index({ baselineId: 1, type: 1 });
DomSnapshotSchema.plugin(toJSON_plugin_default);
DomSnapshotSchema.plugin(paginate_plugin_default);
var DomSnapshot = mongoose14.model("VRSDomSnapshot", DomSnapshotSchema);
// src/server/models/PluginSettings.model.ts
import mongoose15, { Schema as Schema14 } from "mongoose";
var PluginSettingSchemaDefinition = new Schema14({
key: { type: String, required: true },
label: { type: String, required: true },
description: { type: String },
type: {
type: String,
enum: ["string", "number", "boolean", "select", "password"],
required: true
},
defaultValue: { type: Schema14.Types.Mixed },
envVariable: { type: String },
options: [{ value: String, label: String }],
required: { type: Boolean, default: false }
}, { _id: false });
var PluginSettingsSchema = new Schema14({
pluginName: {
type: String,
unique: true,
required: [true, "PluginSettings: pluginName is required"],
index: true
},
displayName: {
type: String,
required: [true, "PluginSettings: displayName is required"]
},
description: {
type: String
},
enabled: {
type: Boolean,
default: false
},
settings: {
type: Schema14.Types.Mixed,
default: {}
},
settingsSchema: {
type: [PluginSettingSchemaDefinition],
default: []
}
}, {
timestamps: true
});
PluginSettingsSchema.plugin(toJSON_plugin_default);
PluginSettingsSchema.statics.getEffectiveConfig = async function(pluginName, envPrefix = "SYNGRISI_PLUGIN_") {
const doc = await this.findOne({ pluginName });
const envPluginKey = pluginName.toUpperCase().replace(/-/g, "_");
const envEnabledKey = `${envPrefix}${envPluginKey}_ENABLED`;
const envEnabled = process.env[envEnabledKey]?.toLowerCase() === "true";
const dbEnabled = doc?.enabled;
const enabled = doc ? dbEnabled : envEnabled;
const config = {};
const schema = doc?.settingsSchema || [];
if (schema.length === 0 && doc?.settings && Object.keys(doc.settings).length > 0) {
for (const [key, value] of Object.entries(doc.settings)) {
config[key] = { value, source: "db" };
}
return { config, enabled };
}
for (const field of schema) {
const envKey = field.envVariable || `${envPrefix}${envPluginKey}_${field.key.toUpperCase()}`;
const envValue = process.env[envKey];
const dbValue = doc?.settings?.[field.key];
if (dbValue !== void 0) {
config[field.key] = { value: dbValue, source: "db" };
} else if (envValue !== void 0) {
let parsedValue = envValue;
if (field.type === "boolean") {
parsedValue = envValue.toLowerCase() === "true";
} else if (field.type === "number") {
parsedValue = parseFloat(envValue);
}
config[field.key] = { value: parsedValue, source: "env" };
} else if (field.defaultValue !== void 0) {
config[field.key] = { value: field.defaultValue, source: "default" };
}
}
return { config, enabled };
};
PluginSettingsSchema.statics.upsertSettings = async function(pluginName, updates) {
return this.findOneAndUpdate(
{ pluginName },
{ $set: updates },
{ upsert: true, new: true, runValidators: true }
);
};
var PluginSettings = mongoose15.model(
"VRSPluginSettings",
PluginSettingsSchema
);
// src/server/utils/calculateAcceptedStatus.ts
var calculateAcceptedStatus = async function calculateAcceptedStatus2(testId) {
const checksInTest = await Check_model_default.find({ test: testId });
const statuses = checksInTest.map((x) => x.markedAs);
if (statuses.length < 1) {
return "Unaccepted";
}
let testCalculatedStatus = "Unaccepted";
if (statuses.some((x) => x === "accepted")) {
testCalculatedStatus = "Partially";
}
if (statuses.every((x) => x === "accepted")) {
testCalculatedStatus = "Accepted";
}
return testCalculatedStatus;
};
// src/server/utils/subDays.ts
var subDays = (date, days) => {
const result = new Date(date);
result.setDate(result.getDate() - days);
return result;
};
var subDays_default = subDays;
// src/server/utils/errMsg.ts
var errMsg = (e) => {
return String(e instanceof Error ? e.stack : e);
};
// src/server/utils/hash.ts
import { createHash, randomUUID } from "crypto";
function hashSync(input) {
return createHash("sha512").update(input).digest("hex");
}
var CROCKFORD_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
function toBase32(bytes) {
let result = "";
let bits = 0;
let value = 0;
for (const byte of bytes) {
value = value << 8 | byte;
bits += 8;
while (bits >= 5) {
bits -= 5;
result += CROCKFORD_ALPHABET[value >> bits & 31];
}
}
if (bits > 0) {
result += CROCKFORD_ALPHABET[value << 5 - bits & 31];
}
return result;
}
function generateApiKey() {
const uuid = randomUUID();
const uuidNoDashes = uuid.replace(/-/g, "");
const buf = Buffer.from(uuidNoDashes, "hex");
let base32 = toBase32(buf);
while (base32.length < 28) {
base32 += CROCKFORD_ALPHABET[0];
}
return `${base32.slice(0, 7)}-${base32.slice(7, 14)}-${base32.slice(14, 21)}-${base32.slice(21, 28)}`;
}
// src/server/utils/stringTable.ts
function createTable(data) {
if (data.length === 0) return "";
const columns = Object.keys(data[0]);
const widths = {};
for (const col of columns) {
widths[col] = col.length;
for (const row of data) {
const value = String(row[col] ?? "");
widths[col] = Math.max(widths[col], value.length);
}
}
const header = columns.map((col) => col.padEnd(widths[col])).join(" | ");
const separator = columns.map((col) => "-".repeat(widths[col])).join("-+-");
const rows = data.map(
(row) => columns.map((col) => String(row[col] ?? "").padEnd(widths[col])).join(" | ")
);
return [header, separator, ...rows].join("\n");
}
// src/server/utils/colors.ts
var RESET = "\x1B[0m";
var colors = {
// Standard colors
blue: (s) => `\x1B[34m${s}${RESET}`,
green: (s) => `\x1B[32m${s}${RESET}`,
red: (s) => `\x1B[31m${s}${RESET}`,
yellow: (s) => `\x1B[33m${s}${RESET}`,
magenta: (s) => `\x1B[35m${s}${RESET}`,
cyan: (s) => `\x1B[36m${s}${RESET}`,
// Bright colors
gray: (s) => `\x1B[90m${s}${RESET}`,
whiteBright: (s) => `\x1B[97m${s}${RESET}`,
// Reset code for manual use
reset: RESET
};
// src/server/utils/httpStatus.ts
var HttpStatus = {
// 2xx Success
OK: 200,
CREATED: 201,
NO_CONTENT: 204,
// 4xx Client Errors
BAD_REQUEST: 400,
UNAUTHORIZED: 401,
FORBIDDEN: 403,
NOT_FOUND: 404,
// 5xx Server Errors
INTERNAL_SERVER_ERROR: 500
};
var httpStatus_default = HttpStatus;
// src/server/utils/cookieParser.ts
function parseCookies(cookieHeader) {
const cookies = /* @__PURE__ */ Object.create(null);
if (!cookieHeader || cookieHeader.length < 2) {
return cookies;
}
const pairs = cookieHeader.split(";");
for (const pair of pairs) {
const eqIdx = pair.indexOf("=");
if (eqIdx < 0) continue;
const key = pair.substring(0, eqIdx).trim();
if (!key) continue;
let val = pair.substring(eqIdx + 1).trim();
if (val.charCodeAt(0) === 34) {
val = val.slice(1, -1);
}
if (cookies[key] === void 0) {
try {
cookies[key] = decodeURIComponent(val);
} catch {
cookies[key] = val;
}
}
}
return cookies;
}
function cookieParser() {
return function cookieParserMiddleware(req, _res, next) {
if (req.cookies) {
next();
return;
}
const cookieHeader = req.headers.cookie;
req.cookies = parseCookies(cookieHeader || "");
next();
};
}
export {
ApiError_default as ApiError,
httpStatus_default as HttpStatus,
ProgressBar,
buildIdentObject,
calculateAcceptedStatus,
catchAsync_default as catchAsync,
colors,
cookieParser,
createTable,
dateToISO8601_default as dateToISO8601,
deserializeIfJSON_default as deserializeIfJSON,
errMsg,
generateApiKey,
getPngDimensions,
hashSync,
ident,
isJSON_default as isJSON,
paramsGuard,
pick_default as pick,
prettyCheckParams_default as prettyCheckParams,
removeEmptyProperties,
subDays_default as subDays,
waitUntil
};
//# sourceMappingURL=index.js.map