@formio/appserver 2.0.0-rc.1 → 2.0.0-rc.31

package/lib/modules/mongodb/db.js

@@ -0,0 +1,832 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const mongodb_1 = require("mongodb");
+const lodash_1 = require("lodash");
+const core_1 = require("@formio/core");
+const debug = require('debug')('formio:db');
+const error = require('debug')('formio:error');
+class Database {
+    constructor(config) {
+        this.config = config;
+        this.prefix = '';
+        this.authQuery = null;
+        this.db = null;
+        this.client = null; // Add this line
+        this.currentCollectionName = 'submissions';
+        this.currentCollection = null;
+        this.defaultCollection = null;
+    }
+    ObjectId(id) {
+        if (id === null || id === void 0 ? void 0 : id.hasOwnProperty('$in')) {
+            return { $in: id['$in'].map((_id) => this.ObjectId(_id)) };
+        }
+        try {
+            return id ? (new mongodb_1.ObjectId(id)) : null;
+        }
+        catch (e) {
+            return id;
+        }
+    }
+    collectionName(name) {
+        return `${this.prefix}${name}`;
+    }
+    /**
+     * Connect to the database.
+     * @returns
+     */
+    connect() {
+        return __awaiter(this, arguments, void 0, function* (prefix = '') {
+            this.prefix = prefix ? `${prefix}.` : '';
+            try {
+                debug('db.connect()');
+                let config = {};
+                if (this.config.config) {
+                    config = (typeof this.config.config === 'string') ? JSON.parse(this.config.config) : this.config.config;
+                }
+                this.client = new mongodb_1.MongoClient(this.config.url, config); // Store the client
+                yield this.client.connect();
+                this.db = yield this.client.db();
+                if (this.config.dropOnConnect) {
+                    yield this.db.dropDatabase();
+                }
+                this.addIndex(this.collection('project'), 'name');
+                this.defaultCollection = this.collection('submissions');
+                yield this.setupIndexes(this.defaultCollection);
+                debug('Connected to database');
+            }
+            catch (err) {
+                error(err.message);
+                process.exit();
+            }
+        });
+    }
+    // Add a close method
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.client) {
+                yield this.client.close();
+                this.client = null;
+                this.db = null;
+            }
+        });
+    }
+    collection(name) {
+        return this.db ? this.db.collection(this.collectionName(name)) : null;
+    }
+    // Generic save record method.
+    save(collectionName, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.db) {
+                return null;
+            }
+            const collection = this.collection(collectionName);
+            if (!collection) {
+                return null;
+            }
+            let result;
+            try {
+                debug('db.save()', collectionName);
+                if (item._id) {
+                    yield collection.updateOne({ _id: this.ObjectId(item._id) }, { $set: (0, lodash_1.omit)(item, '_id') });
+                    return yield collection.findOne({ _id: this.ObjectId(item._id) });
+                }
+                else {
+                    result = yield collection.insertOne(item);
+                    return yield collection.findOne({ _id: this.ObjectId(result.insertedId) });
+                }
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return null;
+        });
+    }
+    saveOne(collectionName, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.db) {
+                return null;
+            }
+            const collection = this.collection(collectionName);
+            if (!collection) {
+                return null;
+            }
+            if (!item._id) {
+                // Try to load an existing record if one exists.
+                let existing = yield this.load(collectionName);
+                if (existing && !existing._id) {
+                    existing._id = new mongodb_1.ObjectId();
+                    const result = yield collection.insertOne(existing);
+                    existing = yield collection.findOne({ _id: this.ObjectId(result.insertedId) });
+                }
+                item._id = existing === null || existing === void 0 ? void 0 : existing._id;
+            }
+            return yield this.save(collectionName, item);
+        });
+    }
+    // Generic load record method.
+    load(collectionName_1) {
+        return __awaiter(this, arguments, void 0, function* (collectionName, dbQuery = {}) {
+            if (!this.db) {
+                return null;
+            }
+            debug('db.load()', collectionName);
+            const collection = this.collection(collectionName);
+            if (!collection) {
+                return null;
+            }
+            let item;
+            try {
+                item = yield collection.findOne(dbQuery);
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return item;
+        });
+    }
+    // Provides a suplemental query for authentication purposes.
+    indexAuth(query) {
+        this.authQuery = query || null;
+    }
+    getQueryValue(name, value, selector) {
+        if (name === 'created' || name === 'modified') {
+            return new Date(value);
+        }
+        if ((typeof value === 'string') && (!selector || (selector === 'eq' || selector === 'ne'))) {
+            const lcValue = value.toLowerCase();
+            if (lcValue === 'null') {
+                return null;
+            }
+            if (lcValue === '"null"') {
+                return 'null';
+            }
+            if (lcValue === 'true') {
+                return true;
+            }
+            if (lcValue === '"true"') {
+                return 'true';
+            }
+            if (lcValue === 'false') {
+                return false;
+            }
+            if (lcValue === '"false"') {
+                return 'false';
+            }
+        }
+        return value;
+    }
+    /**
+     * Converts the url query to query parameters.
+     * @param query
+     * @returns
+     */
+    dbQuery(query = {}) {
+        const dbQuery = {};
+        const { limit, skip, sort } = query, filters = __rest(query, ["limit", "skip", "sort"]);
+        if (limit !== undefined) {
+            dbQuery.limit = limit ? Number(limit) : 10;
+        }
+        if (skip !== undefined) {
+            dbQuery.skip = skip ? Number(skip) : 0;
+        }
+        if (sort) {
+            dbQuery.sort = {};
+            const sortParts = sort.split(',');
+            sortParts.forEach((part) => {
+                const desc = part.charAt(0) === '-';
+                const field = desc ? part.substring(1) : part;
+                dbQuery.sort[field] = desc ? -1 : 1;
+            });
+        }
+        // Iterate through each filter.
+        Object.entries(filters).forEach(([name, value]) => {
+            // Get the filter object.
+            const filter = (0, lodash_1.zipObject)(['name', 'selector'], name.split('__'));
+            if (filter.selector) {
+                var filterQuery = dbQuery[filter.name];
+                // Init the filter.
+                if (!filterQuery) {
+                    filterQuery = {};
+                }
+                if (filter.selector === 'exists') {
+                    value = ((value === 'true') || (value === '1')) ? true : value;
+                    value = ((value === 'false') || (value === '0')) ? false : value;
+                    value = !!value;
+                }
+                else if (filter.selector === 'regex') {
+                    const parts = value.match(/\/?([^/]+)\/?([^/]+)?/);
+                    if (!parts) {
+                        return;
+                    }
+                    try {
+                        value = new RegExp((0, lodash_1.escapeRegExp)(parts[1]), (parts[2] || 'i'));
+                    }
+                    catch (err) {
+                        error(err);
+                        value = null;
+                    }
+                }
+                // Special case for in filter with multiple values.
+                else if (['in', 'nin'].includes(filter.selector)) {
+                    value = Array.isArray(value) ? value : value.split(',');
+                    value = value.map((item) => this.getQueryValue(filter.name, item, filter.selector));
+                }
+                else {
+                    // Set the selector for this filter name.
+                    value = this.getQueryValue(filter.name, value, filter.selector);
+                }
+                filterQuery[`$${filter.selector}`] = value;
+                dbQuery[filter.name] = filterQuery;
+                return;
+            }
+            else {
+                // Set the find query to this value.
+                value = this.getQueryValue(filter.name, value, filter.selector);
+                dbQuery[filter.name] = value;
+                return;
+            }
+        });
+        // If an authQuery is provided, merge it in.
+        if (this.authQuery && (0, lodash_1.isPlainObject)(this.authQuery)) {
+            return (0, lodash_1.merge)(dbQuery, this.authQuery);
+        }
+        // Return the dbQuery.
+        return dbQuery;
+    }
+    // Generic delete record method.
+    remove(collectionName_1) {
+        return __awaiter(this, arguments, void 0, function* (collectionName, dbQuery = {}) {
+            if (!this.db) {
+                return null;
+            }
+            debug('db.remove()', collectionName);
+            const collection = this.collection(collectionName);
+            if (!collection) {
+                return null;
+            }
+            let result;
+            try {
+                result = yield collection.deleteOne(dbQuery);
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return result ? result.deletedCount : null;
+        });
+    }
+    /**
+     * Ensures the form collection is created an returns it.
+     * @returns
+     */
+    formCollection(form) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.db && form && form.settings && form.settings.collection) {
+                if (this.currentCollection && this.currentCollectionName === form.settings.collection) {
+                    return this.currentCollection;
+                }
+                let collection = null;
+                try {
+                    debug('db.createCollection()', form.settings.collection);
+                    yield this.db.createCollection(this.collectionName(form.settings.collection));
+                    collection = this.collection(form.settings.collection);
+                    this.setupIndexes(collection, form);
+                }
+                catch (err) {
+                    error(err.message);
+                }
+                this.currentCollection = collection || this.collection(form.settings.collection);
+                this.currentCollectionName = form.settings.collection;
+                return this.currentCollection;
+            }
+            return this.defaultCollection;
+        });
+    }
+    /**
+     * Setup indexes.
+     */
+    setupIndexes(collection, form) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!collection) {
+                return;
+            }
+            this.addIndex(collection, 'project');
+            this.addIndex(collection, 'form');
+            this.addIndex(collection, 'deleted');
+            this.addIndex(collection, 'modified');
+            // If TTL index is needed add that here.
+            if (this.config.ttl) {
+                try {
+                    collection.createIndex({
+                        created: 1
+                    }, {
+                        background: true,
+                        expireAfterSeconds: this.config.ttl
+                    });
+                }
+                catch (err) {
+                    error('Cannot add TTL index', err.message);
+                }
+            }
+            else {
+                this.addIndex(collection, 'created');
+            }
+            if (form && form.components) {
+                core_1.Utils.eachComponent(form.components, (component, path) => {
+                    if (component.dbIndex) {
+                        this.addIndex(collection, `data.${path}`);
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * Add a field index
+     */
+    addIndex(collection, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!collection) {
+                return;
+            }
+            const index = {};
+            index[path] = 1;
+            try {
+                debug('db.addIndex()', path);
+                collection.createIndex(index, { background: true });
+            }
+            catch (err) {
+                error(`Cannot add index ${path}`, err.message);
+            }
+        });
+    }
+    /**
+     * Adds new indexes to the forms submission collection.
+     * @param indexes
+     * @returns
+     */
+    addIndexes(form, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collection = yield this.formCollection(form);
+            if (!collection) {
+                return;
+            }
+            for (const path of indexes) {
+                yield this.addIndex(collection, `data.${path}`);
+            }
+        });
+    }
+    /**
+     * Remove a field index.
+     */
+    removeIndex(collection, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = {};
+            index[path] = 1;
+            try {
+                debug('db.removeIndex()', path);
+                yield collection.dropIndex(index);
+            }
+            catch (err) {
+                error(`Cannot remove index ${path}`, err.message);
+            }
+        });
+    }
+    /**
+     * Removes indexes to the forms submission collection.
+     * @param indexes
+     * @returns
+     */
+    removeIndexes(form, indexes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collection = yield this.formCollection(form);
+            if (!collection) {
+                return;
+            }
+            for (const path of indexes) {
+                yield this.removeIndex(collection, `data.${path}`);
+            }
+        });
+    }
+    /**
+     * Fetch a list of submissions from a table/collection.
+     * @param {*} table
+     * @param {*} query
+     */
+    index(form_1) {
+        return __awaiter(this, arguments, void 0, function* (form, urlQuery = {}, collection = null) {
+            let items = [], skip = 0, limit = 10, count = 0;
+            try {
+                limit = urlQuery.limit || 10;
+                skip = urlQuery.skip || 0;
+                const sort = urlQuery.sort || { created: -1 };
+                const includeDeleted = urlQuery.includeDeleted || false;
+                let project = {};
+                if (urlQuery.select) {
+                    if (typeof urlQuery.select === 'string') {
+                        const fields = urlQuery.select.split(',');
+                        fields.forEach((field) => {
+                            project[field] = true;
+                        });
+                    }
+                    else {
+                        Object.keys(urlQuery.select).forEach((field) => {
+                            project[field] = true;
+                        });
+                    }
+                }
+                delete urlQuery.limit;
+                delete urlQuery.skip;
+                delete urlQuery.sort;
+                delete urlQuery.select;
+                delete urlQuery.includeDeleted;
+                debug('db.index()', urlQuery);
+                const dbQuery = this.dbQuery(urlQuery);
+                items = (yield this.find(form, dbQuery, limit, skip, sort, project, collection, includeDeleted)) || [];
+                count = yield this.count(form, dbQuery, collection, includeDeleted);
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return { items: items, limit, skip, count };
+        });
+    }
+    /**
+     * Perform a count of the amount of documents within a collection.
+     * @param form
+     * @param query
+     * @returns
+     */
+    count(form_1) {
+        return __awaiter(this, arguments, void 0, function* (form, dbQuery = {}, inCollection = null, includeDeleted = false) {
+            let count = 0;
+            try {
+                debug('db.count()', dbQuery);
+                const collection = inCollection || (yield this.formCollection(form));
+                if (!collection) {
+                    return 0;
+                }
+                count = yield collection.countDocuments(this.query(form, dbQuery, includeDeleted));
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return count;
+        });
+    }
+    /**
+     * Create a new record.
+     */
+    create(form_1, record_1) {
+        return __awaiter(this, arguments, void 0, function* (form, record, allowFields = []) {
+            record.deleted = null;
+            record.created = new Date();
+            record.modified = new Date();
+            if (form && form._id) {
+                record.form = this.ObjectId(form._id);
+            }
+            if (form.project && form.project) {
+                record.project = this.ObjectId(form.project);
+            }
+            if (record.owner) {
+                record.owner = this.ObjectId(record.owner);
+            }
+            const collection = yield this.formCollection(form);
+            try {
+                debug('db.create()', record);
+                const result = yield collection.insertOne((0, lodash_1.pick)(record, [
+                    'data',
+                    'metadata',
+                    'modified',
+                    'created',
+                    'deleted',
+                    'form',
+                    'project',
+                    'owner',
+                    'access',
+                    'state'
+                ].concat(allowFields)));
+                if (!result.insertedId) {
+                    return null;
+                }
+                return yield this.read(form, result.insertedId);
+            }
+            catch (err) {
+                error(err.message);
+                return null;
+            }
+        });
+    }
+    /**
+     * Return a query for a single mongo record.
+     * @param {*} form
+     * @param {*} id
+     * @returns
+     */
+    query(form, query = {}, includeAll = false) {
+        if (query._id) {
+            query._id = this.ObjectId(query._id);
+        }
+        if (query.owner) {
+            query.owner = this.ObjectId(query.owner);
+        }
+        if (query.form) {
+            query.form = this.ObjectId(query.form);
+        }
+        else if (!includeAll && form && form._id) {
+            query.form = this.ObjectId(form._id);
+        }
+        if (!includeAll && form.project) {
+            query.project = this.ObjectId(form.project);
+        }
+        if (!includeAll) {
+            query.deleted = { $eq: null };
+        }
+        // Handle nested queries.
+        ['$or', '$and'].forEach((key) => {
+            if (query[key]) {
+                query[key].forEach((subQuery) => this.query(form, subQuery, true));
+            }
+        });
+        return query;
+    }
+    /**
+     * Find many records that match a query.
+     */
+    find(form_1) {
+        return __awaiter(this, arguments, void 0, function* (form, dbQuery = {}, limit = 10, skip = 0, sort = { created: -1 }, select = {}, inCollection = null, includeDeleted = false) {
+            try {
+                debug('db.find()', dbQuery);
+                const collection = inCollection || (yield this.formCollection(form));
+                if (!collection) {
+                    return [];
+                }
+                return yield collection.find(this.query(form, dbQuery, includeDeleted)).limit(limit).skip(skip).sort(sort).project(select).toArray();
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return [];
+        });
+    }
+    /**
+     * Find a record for a provided query.
+     */
+    findOne(form_1) {
+        return __awaiter(this, arguments, void 0, function* (form, dbQuery = {}, options = {}) {
+            try {
+                debug('db.findOne()', dbQuery);
+                const collection = yield this.formCollection(form);
+                if (!collection) {
+                    return null;
+                }
+                const doc = yield collection.findOne(this.query(form, dbQuery));
+                if (!doc) {
+                    return null;
+                }
+                return doc;
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return null;
+        });
+    }
+    /**
+     * Read a single submission from a form
+     *
+     * @param {*} table
+     * @param {*} query
+     */
+    read(form, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                debug('db.read()', id);
+                if (!id) {
+                    return null;
+                }
+                const collection = yield this.formCollection(form);
+                if (!collection) {
+                    return null;
+                }
+                const doc = yield collection.findOne(this.query(form, { _id: this.ObjectId(id) }));
+                if (!doc) {
+                    return null;
+                }
+                return doc;
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return null;
+        });
+    }
+    /**
+     * Update a single submission of a form.
+     *
+     * @param {*} table
+     * @param {*} query
+     */
+    update(form_1, id_1, update_1) {
+        return __awaiter(this, arguments, void 0, function* (form, id, update, allowFields = []) {
+            if (!id || !update) {
+                return null;
+            }
+            update.modified = new Date();
+            try {
+                debug('db.update()', id, update);
+                const collection = yield this.formCollection(form);
+                if (!collection) {
+                    return null;
+                }
+                const result = yield collection.updateOne(this.query(form, { _id: this.ObjectId(id) }), {
+                    $set: (0, lodash_1.pick)(update, ['data', 'metadata', 'modified', 'state'].concat(allowFields))
+                });
+                if (result.modifiedCount === 0) {
+                    return null;
+                }
+                return yield this.read(form, id);
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return null;
+        });
+    }
+    /**
+     * Delete a record from the database.
+     */
+    delete(form_1, id_1) {
+        return __awaiter(this, arguments, void 0, function* (form, id, hard = false) {
+            if (!id) {
+                return false;
+            }
+            try {
+                debug('db.delete()', id, hard ? '(hard)' : '(soft)');
+                const collection = yield this.formCollection(form);
+                if (!collection) {
+                    return false;
+                }
+                if (hard) {
+                    // Hard delete - completely remove the record from the database
+                    const result = yield collection.deleteOne(this.query(form, { _id: this.ObjectId(id) }, true));
+                    return result.deletedCount > 0;
+                }
+                else {
+                    // Soft delete - set deleted timestamp
+                    const result = yield collection.updateOne(this.query(form, { _id: this.ObjectId(id) }), {
+                        $set: {
+                            deleted: new Date(),
+                            modified: new Date()
+                        }
+                    });
+                    return result.modifiedCount > 0;
+                }
+            }
+            catch (err) {
+                error(err.message);
+            }
+            return false;
+        });
+    }
+    addPathQueryParams(pathQueryParams, query, path) {
+        const pathArray = path.split(/\[\d+\]?./);
+        const needValuesInArray = pathArray.length > 1;
+        let pathToValue = path;
+        if (needValuesInArray) {
+            pathToValue = pathArray.shift();
+            if (!pathToValue) {
+                return;
+            }
+            const pathQueryObj = {};
+            (0, lodash_1.reduce)(pathArray, (pathQueryPath, pathPart, index) => {
+                const isLastPathPart = index === (pathArray.length - 1);
+                const obj = (0, lodash_1.get)(pathQueryObj, pathQueryPath, pathQueryObj);
+                const addedPath = `$elemMatch['${pathPart}']`;
+                (0, lodash_1.set)(obj, addedPath, isLastPathPart ? pathQueryParams : {});
+                return pathQueryPath ? `${pathQueryPath}.${addedPath}` : addedPath;
+            }, '');
+            query[pathToValue] = pathQueryObj;
+        }
+        else {
+            query[pathToValue] = pathQueryParams;
+        }
+    }
+    /**
+     * Performs a unique query on the database to see if a value is unique.
+     *  - If the value is unique, it returns true.
+     *  - If the value is not unique, it returns the id of the non-unique submission.
+     *  - If an error occurs, or uniqueness cannot be determined, it will throw an error.
+     *
+     * @param form
+     * @param context
+     * @param value
+     * @returns
+     */
+    isUnique(form, component, submission, componentPath, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = `data.${componentPath}`;
+            if (!form) {
+                return false;
+            }
+            // Build the query
+            const query = { form: form._id };
+            let options = {};
+            if ((0, lodash_1.isString)(value)) {
+                if (component.dbIndex) {
+                    this.addPathQueryParams(value, query, path);
+                }
+                else if (component.type === 'email' ||
+                    (component.type === 'textfield' &&
+                        component.validate &&
+                        component.validate.pattern === '[A-Za-z0-9]+')) {
+                    this.addPathQueryParams(value, query, path);
+                    options = { collation: { locale: 'en', strength: 2 } };
+                }
+                else {
+                    this.addPathQueryParams({
+                        $regex: new RegExp(`^${(0, core_1.escapeRegExCharacters)(value)}$`),
+                        $options: 'i'
+                    }, query, path);
+                }
+            }
+            // FOR-213 - Pluck the unique location id
+            else if ((0, lodash_1.isPlainObject)(value) &&
+                value.address &&
+                value.address['address_components'] &&
+                value.address['place_id']) {
+                this.addPathQueryParams({
+                    $regex: new RegExp(`^${(0, core_1.escapeRegExCharacters)(value.address['place_id'])}$`),
+                    $options: 'i'
+                }, query, `${path}.address.place_id`);
+            }
+            // Compare the contents of arrays vs the order.
+            else if ((0, lodash_1.isArray)(value)) {
+                this.addPathQueryParams({ $all: value }, query, path);
+            }
+            else if ((0, lodash_1.isObject)(value) || (0, lodash_1.isNumber)(value)) {
+                this.addPathQueryParams({ $eq: value }, query, path);
+            }
+            // Only search for non-deleted items
+            query.deleted = { $eq: null };
+            query.state = 'submitted';
+            // Perform the query.
+            let result = null;
+            try {
+                result = yield this.findOne(form, query, options);
+                if (!(result === null || result === void 0 ? void 0 : result._id) || ((result === null || result === void 0 ? void 0 : result._id.toString()) === (submission === null || submission === void 0 ? void 0 : submission._id))) {
+                    return true;
+                }
+                else {
+                    return result._id.toString();
+                }
+            }
+            catch (err) {
+                if (options.collation) {
+                    // presume this error comes from db compatibility, try again as regex
+                    delete query[path];
+                    this.addPathQueryParams({
+                        $regex: new RegExp(`^${(0, core_1.escapeRegExCharacters)(value)}$`),
+                        $options: 'i'
+                    }, query, path);
+                    try {
+                        result = yield this.findOne(form, query);
+                        if (!(result === null || result === void 0 ? void 0 : result._id) || ((result === null || result === void 0 ? void 0 : result._id.toString()) === (submission === null || submission === void 0 ? void 0 : submission._id))) {
+                            return true;
+                        }
+                        else {
+                            component.conflictId = result._id.toString();
+                            return component.conflictId;
+                        }
+                    }
+                    catch (err) {
+                        throw err;
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+}
+exports.Database = Database;