@syngrisi/syngrisi 2.2.1

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

@@ -0,0 +1,76 @@
+"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

@@ -0,0 +1,76 @@
+"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

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

package/dist/src/server/schemas/createCheck.shema.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckParamsSchema = void 0;
+const zod_1 = require("zod");
+exports.createCheckParamsSchema = zod_1.z.object({
+    branch: zod_1.z.string().min(1),
+    appName: zod_1.z.string().min(1),
+    suitename: zod_1.z.string().min(1),
+    testid: zod_1.z.string().regex(/^[a-f0-9]{24}$/),
+    name: zod_1.z.string().min(1),
+    viewport: zod_1.z.string().regex(/^\d+x\d+$/),
+    browserName: zod_1.z.string().min(1),
+    browserVersion: zod_1.z.string().min(1),
+    browserFullVersion: zod_1.z.string(),
+    os: zod_1.z.string().min(1),
+    hashcode: zod_1.z.string().length(128) // Assuming hashcode is always 128 chars length
+});

package/dist/src/server/schemas/getBaseline.shema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredIdentOptionsSchema = void 0;
+const zod_1 = require("zod");
+exports.RequiredIdentOptionsSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    viewport: zod_1.z.string().min(3),
+    browserName: zod_1.z.string().min(1),
+    os: zod_1.z.string().min(1),
+    app: zod_1.z.string().min(1),
+    branch: zod_1.z.string().min(1),
+});

package/dist/src/server/utils/paramsGuard.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramsGuard = void 0;
+const 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)}
+        \n error: ${result.error?.stack || result.error}
+        \n params: ${JSON.stringify(params, null, 2)}
+        `);
+    }
+};
+exports.paramsGuard = paramsGuard;

package/dist/src/tasks/backup.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("@inquirer/prompts");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../../config");
+const run = async () => {
+    const backupFolder = config_1.config.backupsFolder;
+    if (!fs.existsSync(backupFolder)) {
+        fs.mkdirSync(backupFolder, { recursive: true });
+    }
+    console.log('Please be sure that \'mongodump\', \'mongorestore\' and \'rsync\' tools are present in your system.');
+    const currDate = new Date().toLocaleString('en-US', { year: 'numeric', month: '2-digit', day: 'numeric' })
+        .replace(/[/]/gm, '_');
+    const backupSubFolder = `${currDate}_${Date.now()}`;
+    const answers = {
+        folder: await (0, prompts_1.input)({ message: 'Enter the Backup Folder name Filename', default: backupSubFolder }),
+        connectionString: await (0, prompts_1.input)({ message: 'Enter the Database Connection String URI', default: config_1.config.connectionString }),
+        imagesPath: await (0, prompts_1.input)({ message: 'Enter the Images Folder Path', default: config_1.config.defaultImagesPath }),
+        confirm: await (0, prompts_1.confirm)({ message: 'Continue?' }),
+    };
+    if (!answers.confirm) {
+        return "Skipped";
+    }
+    const fullBackupPath = path.join(backupFolder, answers.folder);
+    if (fs.existsSync(fullBackupPath)) {
+        console.log('The folder is already exists, please enter another folder ');
+        return;
+    }
+    fs.mkdirSync(fullBackupPath, { recursive: true });
+    const destDatabasePath = path.join(fullBackupPath, 'database');
+    fs.mkdirSync(destDatabasePath, { recursive: true });
+    const destImagesPath = path.join(fullBackupPath, 'images');
+    fs.mkdirSync(fullBackupPath, { recursive: true });
+    console.log('Backup the Database');
+    const dbDumpResult = (0, child_process_1.execSync)(`mongodump --uri=${answers.connectionString} --gzip --out ${destDatabasePath}`).toString();
+    console.log(dbDumpResult);
+    console.log('Backup Images');
+    const imagesBackupResult = (0, child_process_1.execSync)(`rsync -vah --progress ${answers.imagesPath} ${destImagesPath}`)
+        .toString('utf8');
+    console.log(imagesBackupResult);
+    return '✅ Success';
+};
+run().then((result) => console.log(`operation complete: ${result}`));

package/dist/src/tasks/lib/common.js

@@ -0,0 +1,14 @@
+"use strict";
+const { Snapshot, Check, Test, Run, App, Suite, User, Baseline, } = require('../../server/models');
+// const url = 'mongodb://localhost/VRSdb';
+module.exports = {
+    // url,
+    User,
+    Snapshot,
+    Check,
+    Test,
+    Run,
+    App,
+    Suite,
+    Baseline,
+};

package/dist/src/tasks/lib/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+const mongoose = require('mongoose');
+const { url } = require('./common');
+const connect = async () => {
+    const connection = await mongoose.connect(url, {});
+    console.log(`Mongoose default connection open to: '${url}', models: '${Object.keys(connection.models)
+        .join(', ')}'`);
+    return connection;
+};
+module.exports.runMongoCode = async (cb) => {
+    await connect();
+    await cb();
+    await mongoose.connection.close();
+};

package/dist/src/tasks/migrations/2.0.migration.js

@@ -0,0 +1,86 @@
+"use strict";
+/* eslint-disable no-await-in-loop,no-restricted-syntax */
+require('../../server/models');
+const utils = require('../lib/utils');
+const { Check, Test, Run, Suite } = require('../lib/common');
+async function task() {
+    await utils.runMongoCode(async () => {
+        try {
+            /**
+             * 0. fill test collection with 'checks' field array
+             * */
+            console.log('\nStage: 0');
+            const checks = await Check.find({});
+            // console.log(checks);
+            for (const check of checks) {
+                const testId = check.test;
+                const test = await Test.findOne({ _id: testId });
+                if (test && testId && !test.checks.map((x) => x.toString()).includes(check?._id.toString())) {
+                    const newChecksArray = test.checks || [];
+                    newChecksArray.push(check._id);
+                    await test.update({ _id: test._id }, { $set: { checks: newChecksArray } });
+                    await test.save();
+                    process.stdout.write('.');
+                }
+                else {
+                    process.stdout.write('x');
+                }
+            }
+            /**
+             * 1. fill test suite fields
+             * */
+            console.log('\nStage: 1');
+            const tests = await Test.find({});
+            for (const test of tests) {
+                // console.log(test.checks[0]);
+                const firstCheckId = test.checks[0];
+                if (firstCheckId) {
+                    // @ts-ignore
+                    const firstCheck = await Check.findOne({ _id: test.checks[0] });
+                    if (firstCheck) {
+                        const { suite } = firstCheck;
+                        if (suite) {
+                            test.suite = suite;
+                            await Test.update({ _id: test._id }, { $set: { suite } });
+                        }
+                    }
+                }
+                else {
+                    process.stdout.write('x');
+                }
+                process.stdout.write('.');
+            }
+            /**
+             * 2. set app id for runs and suites
+             * */
+            console.log('\nStage: 2');
+            for (const x of tests) {
+                const appId = x.app;
+                await Run.update({ _id: x.run }, { $set: { app: appId } });
+                await Suite.update({ _id: x.suite }, { $set: { app: appId } });
+                process.stdout.write('.');
+            }
+            /**
+             * 3. populate 'runs' and 'suites' with 'createdDate' field
+             * */
+            console.log('\nStage: 3');
+            const suites = await Suite.find({});
+            for (const x of suites) {
+                await Suite.update({ _id: x._id }, { $set: { createdDate: x._id.getTimestamp() } });
+                process.stdout.write('+');
+            }
+            const runs = await Run.find({});
+            for (const x of runs) {
+                await Run.update({ _id: x._id }, { $set: { createdDate: x._id.getTimestamp() } });
+                process.stdout.write('>');
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            console.log('\nDone');
+        }
+    });
+}
+task();

package/dist/src/tasks/migrations/2.0.migration_mql.js

@@ -0,0 +1,57 @@
+"use strict";
+/* eslint-disable */
+/**
+ * 0. fill test collection with 'checks' field array
+ **/
+const checks = db.vrschecks.find({}).toArray();
+for (const check of checks) {
+    const testId = check.test;
+    if (testId) {
+        const test = db.vrstests.findOne({ _id: testId });
+        const newChecksArray = test.checks || [];
+        newChecksArray.push(check._id);
+        db.vrstests.update({ _id: test._id }, { $set: { "checks": newChecksArray } });
+    }
+}
+/**
+ * 1. fill test suite fields
+ **/
+const tests = db.vrstests.find({}).toArray();
+tests.forEach((test) => {
+    console.log(test.checks[0]);
+    const firstCheckId = test.checks[0];
+    if (firstCheckId) {
+        const firstCheck = db.vrschecks.findOne({ _id: test.checks[0] });
+        if (firstCheck) {
+            const suite = firstCheck.suite;
+            if (suite) {
+                test.suite = suite;
+            }
+        }
+    }
+    else {
+        console.log('Cannot find checks');
+    }
+});
+/**
+ * 2. set app id for runs and suites
+ **/
+db.vrstests.find({}).forEach((x) => {
+    const appId = x.app;
+    console.log({ appId });
+    db.vrsruns.update({ _id: x.run }, { $set: { "app": appId } });
+    db.vrssuites.update({ _id: x.suite }, { $set: { "app": appId } });
+});
+/**
+ * 3. populate 'runs' and 'suites' with 'createdDate' field
+ **/
+db.vrssuites.find({}).forEach((x) => {
+    // x.createdDate = x._id.getTimestamp();
+    db.vrssuites.update({ _id: x._id }, { $set: { "createdDate": x._id.getTimestamp() } });
+    console.log(x.updatedDate);
+});
+db.vrsruns.find({}).forEach((x) => {
+    // x.createdDate = x._id.getTimestamp();
+    db.vrsruns.update({ _id: x._id }, { $set: { "createdDate": x._id.getTimestamp() } });
+    console.log(x.updatedDate);
+});

package/dist/src/tasks/reindex.js

@@ -0,0 +1,28 @@
+"use strict";
+require('../server/models');
+const utils = require('./lib/utils');
+const { User, Snapshot, Check, Test, Run, Log, App, Suite, Baseline, } = require('./lib/common');
+(async () => {
+    await utils.runMongoCode(() => {
+        return new Promise(async (resolve, reject) => {
+            const result = [];
+            [User, Snapshot, Check, Test, Run, Log, App, Suite, Baseline].forEach((model) => {
+                result.push(model.collection.dropIndexes()
+                    .then(() => {
+                    console.log(`Drop: '${model.collection.name}'`);
+                })
+                    .catch((err) => {
+                    console.log(`Cannot drop index '${model.collection.name}', error: '${err}' `);
+                }));
+            });
+            return resolve(await Promise.all(result)
+                .catch((err) => {
+                console.log('ERROR:');
+                console.error(err);
+            })
+                .then(() => {
+                console.log('End of reindex task');
+            }));
+        });
+    });
+})();

package/dist/src/tasks/restore.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const prompts_1 = require("@inquirer/prompts");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../../config");
+const run = async () => {
+    const backupFolder = config_1.config.backupsFolder;
+    if (!fs.existsSync(backupFolder)) {
+        fs.mkdirSync(backupFolder, { recursive: true });
+    }
+    console.log('Be sure that Application is down and \'mongodump\', \'mongorestore\' and \'rsync\' tools are present in your system.');
+    const backupsFolders = fs.readdirSync(backupFolder, { withFileTypes: true })
+        .filter((x) => x.isDirectory())
+        .map((x) => ({ name: x.name, value: x.name }));
+    const answers = {
+        backupSubFolder: await (0, prompts_1.select)({ message: 'Enter the Backup Folder name Filename', choices: backupsFolders }),
+        destConnectionString: await (0, prompts_1.input)({ message: 'Enter the Destination Database Connection String URI', default: config_1.config.connectionString }),
+        destImagesSubFolder: await (0, prompts_1.input)({ message: 'Enter the Images Folder Path', default: config_1.config.defaultImagesPath }),
+        confirm: await (0, prompts_1.confirm)({ message: '⚠️ Caution! All current Application Data will be removed, before the Restoring! Continue?', default: false }),
+    };
+    if (!answers.confirm) {
+        return 'Skipped';
+    }
+    const fullBackupPath = path.join(backupFolder, answers.backupSubFolder);
+    console.log({ fullBackupPath });
+    const fullSourceDatabasePath = path.join(fullBackupPath, 'database');
+    if (!fs.existsSync(fullSourceDatabasePath)) {
+        console.log('The Source Database Folder is not exists, please select tha another folder');
+        return;
+    }
+    const fullSourceImagesPath = path.join(fullBackupPath, 'images');
+    if (!fs.existsSync(fullSourceImagesPath)) {
+        console.log('The Source Images Folder is not exists, please select tha another folder');
+        return;
+    }
+    if (!fs.existsSync(answers.destImagesSubFolder)) {
+        console.log('The Destination Images Folder is not exists, please select tha another folder');
+        return;
+    }
+    console.log('Remove the Destination Database');
+    const removeDbResult = (0, child_process_1.execSync)(`mongosh '${answers.destConnectionString}' --eval "db.dropDatabase();"`)
+        .toString();
+    console.log(removeDbResult);
+    console.log('Restore the Database');
+    const restoreDbResult = (0, child_process_1.execSync)(`mongorestore --uri ${answers.destConnectionString} --gzip ${fullSourceDatabasePath}/*`)
+        .toString();
+    console.log(restoreDbResult);
+    console.log('Clean the Destination Images Folder');
+    // eslint-disable-next-line max-len
+    const removeImagesResult = (0, child_process_1.execSync)(`ls ${answers.destImagesSubFolder};rm -rfv ${answers.destImagesSubFolder} && mkdir ${answers.destImagesSubFolder}`)
+        .toString();
+    console.log(removeImagesResult);
+    console.log('Restore the Images');
+    console.log({ fullSourceImagesPath });
+    const restoreImagesResult = (0, child_process_1.execSync)(`rsync -vah --progress  ${fullSourceImagesPath}/ ${answers.destImagesSubFolder}`)
+        .toString('utf8');
+    console.log(restoreImagesResult);
+    return '✅ Success';
+};
+run().then((result) => console.log(`operation complete: ${result}`));