forms-angular 0.12.0-beta.193 → 0.12.0-beta.194

package/dist/server/data_form.js

@@ -1,64 +1,13 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-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 __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormsAngular = void 0;
 // This part of forms-angular borrows _very_ heavily from https://github.com/Alexandre-Strzelewicz/angular-bridge
 // (now https://github.com/Unitech/angular-bridge
-var _ = require('lodash');
-var util = require('util');
-var extend = require('node.extend');
-var async = require('async');
-var debug = false;
+const _ = require('lodash');
+const util = require('util');
+const extend = require('node.extend');
+const async = require('async');
+let debug = false;
 function logTheAPICalls(req, res, next) {
     void (res);
     console.log('API     : ' + req.method + ' ' + req.url + '  [ ' + JSON.stringify(req.body) + ' ]');
@@ -66,8 +15,8 @@ function logTheAPICalls(req, res, next) {
 }
 function processArgs(options, array) {
     if (options.authentication) {
-        var authArray = _.isArray(options.authentication) ? options.authentication : [options.authentication];
-        for (var i = authArray.length - 1; i >= 0; i--) {
+        let authArray = _.isArray(options.authentication) ? options.authentication : [options.authentication];
+        for (let i = authArray.length - 1; i >= 0; i--) {
             array.splice(1, 0, authArray[i]);
         }
     }
@@ -77,8 +26,8 @@ function processArgs(options, array) {
     array[0] = options.urlPrefix + array[0];
     return array;
 }
-var FormsAngular = /** @class */ (function () {
-    function FormsAngular(mongoose, app, options) {
+class FormsAngular {
+    constructor(mongoose, app, options) {
         this.mongoose = mongoose;
         this.app = app;
         app.locals.formsAngular = app.locals.formsAngular || [];
@@ -90,7 +39,7 @@ var FormsAngular = /** @class */ (function () {
         }, options || {});
         this.resources = [];
         this.searchFunc = async.forEach;
-        var search = 'search/', schema = 'schema/', report = 'report/', resourceName = ':resourceName', id = '/:id';
+        const search = 'search/', schema = 'schema/', report = 'report/', resourceName = ':resourceName', id = '/:id';
         this.app.get.apply(this.app, processArgs(this.options, ['models', this.models()]));
         this.app.get.apply(this.app, processArgs(this.options, [search + resourceName, this.search()]));
         this.app.get.apply(this.app, processArgs(this.options, [schema + resourceName, this.schema()]));
@@ -99,50 +48,53 @@ var FormsAngular = /** @class */ (function () {
         this.app.get.apply(this.app, processArgs(this.options, [report + resourceName + '/:reportName', this.report()]));
         this.app.get.apply(this.app, processArgs(this.options, [resourceName, this.collectionGet()]));
         this.app.post.apply(this.app, processArgs(this.options, [resourceName, this.collectionPost()]));
+        // return the List attributes for all records - used by record-handler's setUpLookupOptions() method, for cases
+        // where there's a lookup that doesn't use the fngajax option 
+        this.app.get.apply(this.app, processArgs(this.options, [resourceName + '/listAll', this.entityListAll()]));
         this.app.get.apply(this.app, processArgs(this.options, [resourceName + id, this.entityGet()]));
         this.app.post.apply(this.app, processArgs(this.options, [resourceName + id, this.entityPut()])); // You can POST or PUT to update data
         this.app.put.apply(this.app, processArgs(this.options, [resourceName + id, this.entityPut()]));
         this.app.delete.apply(this.app, processArgs(this.options, [resourceName + id, this.entityDelete()]));
-        // return the List attributes for a record - used by select2
+        // return the List attributes for a record - used by fng-ui-select
         this.app.get.apply(this.app, processArgs(this.options, [resourceName + id + '/list', this.entityList()]));
         this.app.get.apply(this.app, processArgs(this.options, ['search', this.searchAll()]));
-        for (var pluginName in this.options.plugins) {
+        for (let pluginName in this.options.plugins) {
             if (this.options.plugins.hasOwnProperty(pluginName)) {
-                var pluginObj = this.options.plugins[pluginName];
+                let pluginObj = this.options.plugins[pluginName];
                 this.options.plugins[pluginName] = Object.assign(this.options.plugins[pluginName], pluginObj.plugin(this, processArgs, pluginObj.options));
             }
         }
     }
-    FormsAngular.prototype.getListFields = function (resource, doc, cb) {
-        function getFirstMatchingField(keyList, type) {
-            for (var i = 0; i < keyList.length; i++) {
-                var fieldDetails = resource.model.schema['tree'][keyList[i]];
-                if (fieldDetails.type && (!type || fieldDetails.type.name === type) && keyList[i] !== '_id') {
-                    resource.options.listFields = [{ field: keyList[i] }];
-                    return doc[keyList[i]];
-                }
+    getFirstMatchingField(resource, doc, keyList, type) {
+        for (let i = 0; i < keyList.length; i++) {
+            let fieldDetails = resource.model.schema['tree'][keyList[i]];
+            if (fieldDetails.type && (!type || fieldDetails.type.name === type) && keyList[i] !== '_id') {
+                resource.options.listFields = [{ field: keyList[i] }];
+                return doc ? doc[keyList[i]] : keyList[i];
             }
         }
-        var that = this;
-        var display = '';
-        var listFields = resource.options.listFields;
+    }
+    getListFields(resource, doc, cb) {
+        const that = this;
+        let display = '';
+        let listFields = resource.options.listFields;
         if (listFields) {
             async.map(listFields, function (aField, cbm) {
                 if (typeof doc[aField.field] !== 'undefined') {
                     if (aField.params) {
                         if (aField.params.ref) {
-                            var fieldOptions = resource.model.schema['paths'][aField.field].options;
+                            let fieldOptions = resource.model.schema['paths'][aField.field].options;
                             if (typeof fieldOptions.ref === 'string') {
-                                var lookupResource_1 = that.getResource(fieldOptions.ref);
-                                if (lookupResource_1) {
-                                    var hiddenFields = that.generateHiddenFields(lookupResource_1, false);
+                                let lookupResource = that.getResource(fieldOptions.ref);
+                                if (lookupResource) {
+                                    let hiddenFields = that.generateHiddenFields(lookupResource, false);
                                     hiddenFields.__v = false;
-                                    lookupResource_1.model.findOne({ _id: doc[aField.field] }).select(hiddenFields).exec(function (err, doc2) {
+                                    lookupResource.model.findOne({ _id: doc[aField.field] }).select(hiddenFields).exec(function (err, doc2) {
                                         if (err) {
                                             cbm(err);
                                         }
                                         else {
-                                            that.getListFields(lookupResource_1, doc2, cbm);
+                                            that.getListFields(lookupResource, doc2, cbm);
                                         }
                                     });
                                 }
@@ -152,7 +104,7 @@ var FormsAngular = /** @class */ (function () {
                             }
                         }
                         else if (aField.params.params === 'timestamp') {
-                            var date = that.extractTimestampFromMongoID(doc[aField.field]);
+                            let date = that.extractTimestampFromMongoID(doc[aField.field]);
                             cbm(null, date.toLocaleDateString() + ' ' + date.toLocaleTimeString());
                         }
                     }
@@ -178,29 +130,61 @@ var FormsAngular = /** @class */ (function () {
             });
         }
         else {
-            var keyList = Object.keys(resource.model.schema['tree']);
+            const keyList = Object.keys(resource.model.schema['tree']);
             // No list field specified - use the first String field,
-            display = getFirstMatchingField(keyList, 'String') ||
+            display = this.getFirstMatchingField(resource, doc, keyList, 'String') ||
                 // and if there aren't any then just take the first field
-                getFirstMatchingField(keyList);
+                this.getFirstMatchingField(resource, doc, keyList);
             cb(null, display.trim());
         }
-    };
+    }
+    ;
+    // generate a Mongo projection that can be used to restrict a query to return only those fields from the given
+    // resource that are identified as "list" fields (i.e., ones that should appear whenever records of that type are
+    // displayed in a list)
+    generateListFieldProjection(resource) {
+        const projection = {};
+        const listFields = resource.options?.listFields;
+        // resource.options.listFields will identify all of the fields from resource that have a value for .list.
+        // generally, that value will be "true", identifying the corresponding field as one which should be
+        // included whenever records of that type appear in a list.
+        // occasionally, it will instead be "{ ref: true }"", which means something entirely different -
+        // this means that the field requires a lookup translation before it can be displayed on a form.
+        // for our purposes, we're interested in only the first of these two cases, so we'll ignore anything where
+        // field.params.ref has a truthy value
+        if (listFields) {
+            for (const field of listFields) {
+                if (!field.params?.ref) {
+                    projection[field.field] = 1;
+                }
+            }
+        }
+        else {
+            const keyList = Object.keys(resource.model.schema['tree']);
+            const firstField = (
+            // No list field specified - use the first String field,
+            this.getFirstMatchingField(resource, undefined, keyList, 'String') ||
+                // and if there aren't any then just take the first field
+                this.getFirstMatchingField(resource, undefined, keyList));
+            projection[firstField] = 1;
+        }
+        return projection;
+    }
     ;
-    FormsAngular.prototype.newResource = function (model, options) {
+    newResource(model, options) {
         options = options || {};
         options.suppressDeprecatedMessage = true;
-        var passModel = model;
+        let passModel = model;
         if (typeof model !== 'function') {
             passModel = model.model;
         }
         this.addResource(passModel.modelName, passModel, options);
-    };
+    }
     ;
     //    Add a resource, specifying the model and any options.
     //    Models may include their own options, which means they can be passed through from the model file
-    FormsAngular.prototype.addResource = function (resourceName, model, options) {
-        var resource = {
+    addResource(resourceName, model, options) {
+        let resource = {
             resourceName: resourceName,
             options: options || {}
         };
@@ -212,7 +196,7 @@ var FormsAngular = /** @class */ (function () {
         }
         else {
             resource.model = model.model;
-            for (var prop in model) {
+            for (const prop in model) {
                 if (model.hasOwnProperty(prop) && prop !== 'model') {
                     resource.options[prop] = model[prop];
                 }
@@ -230,30 +214,89 @@ var FormsAngular = /** @class */ (function () {
         else {
             this.resources.push(resource);
         }
-    };
+    }
     ;
-    FormsAngular.prototype.getResource = function (name) {
+    getResource(name) {
         return _.find(this.resources, function (resource) {
             return resource.resourceName === name;
         });
-    };
+    }
     ;
-    FormsAngular.prototype.getResourceFromCollection = function (name) {
+    getResourceFromCollection(name) {
         return _.find(this.resources, function (resource) {
             return resource.model.collection.collectionName === name;
         });
-    };
+    }
     ;
-    FormsAngular.prototype.internalSearch = function (req, resourcesToSearch, includeResourceInResults, limit, callback) {
-        var _a, _b, _c, _d;
+    // Using the given (already-populated) AmbiguousRecordStore, generate text suitable for
+    // disambiguation of each ambiguous record, and pass that to the given disambiguateItemCallback
+    // so our caller can decorate the ambiguous record in whatever way it deems appropriate.
+    //
+    // The ambiguousRecordStore provided to this function (generated either by a call to
+    // buildSingleResourceAmbiguousRecordStore() or buildMultiResourceAmbiguousRecordStore()) will
+    // already be grouping records by the resource that should be used to disambiguate them, with
+    // the name of that resource being the primary index property of the store.
+    //
+    // The disambiguation text will be the concatenation (space-seperated) of the list fields for
+    // the doc from that resource whose _id matches the value of record[disambiguationField].
+    //
+    // allRecords should include all of the ambiguous records (also held by AmbiguousRecordStore)
+    // as well as those found not to be ambiguous.  The final act of this function will be to delete
+    // the disambiguation field from those records - it is only going to be there for the purpose
+    // of disambiguation, and should not be returned by our caller once disambiguation is complete.
+    //
+    // The scary-looking templating used here ensures that the objects in allRecords (and also
+    // ambiguousRecordStore) include an (optional) string property with the name identified by
+    // disambiguationField.  For the avoidance of doubt, "prop" here could be anything - "foo in f"
+    // would achieve the same result.
+    disambiguate(allRecords, ambiguousRecordStore, disambiguationField, disambiguateItemCallback, completionCallback) {
+        const that = this;
+        async.map(Object.keys(ambiguousRecordStore), function (resourceName, cbm) {
+            const resource = that.getResource(resourceName);
+            const projection = that.generateListFieldProjection(resource);
+            resource.model
+                .find({ _id: { $in: ambiguousRecordStore[resourceName].map((sr) => sr[disambiguationField]) } })
+                .select(projection)
+                .lean()
+                .then((disambiguationRecs) => {
+                for (const ambiguousResult of ambiguousRecordStore[resourceName]) {
+                    const disambiguator = disambiguationRecs.find((d) => d._id.toString() === ambiguousResult[disambiguationField].toString());
+                    if (disambiguator) {
+                        let suffix = "";
+                        for (const listField in projection) {
+                            if (disambiguator[listField]) {
+                                if (suffix) {
+                                    suffix += " ";
+                                }
+                                suffix += disambiguator[listField];
+                            }
+                        }
+                        if (suffix) {
+                            disambiguateItemCallback(ambiguousResult, suffix);
+                        }
+                    }
+                }
+                cbm(null);
+            })
+                .catch((err) => {
+                cbm(err);
+            });
+        }, (err) => {
+            for (const record of allRecords) {
+                delete record[disambiguationField];
+            }
+            completionCallback(err);
+        });
+    }
+    internalSearch(req, resourcesToSearch, includeResourceInResults, limit, callback) {
         if (typeof req.query === 'undefined') {
             req.query = {};
         }
-        var timestamps = { sentAt: req.query.sentAt, startedAt: new Date().valueOf(), completedAt: undefined };
-        var searches = [], resourceCount = resourcesToSearch.length, searchFor = req.query.q || '', filter = req.query.f;
+        const timestamps = { sentAt: req.query.sentAt, startedAt: new Date().valueOf(), completedAt: undefined };
+        let searches = [], resourceCount = resourcesToSearch.length, searchFor = req.query.q || '', filter = req.query.f;
         function translate(string, array, context) {
             if (array) {
-                var translation = _.find(array, function (fromTo) {
+                let translation = _.find(array, function (fromTo) {
                     return fromTo.from === string && (!fromTo.context || fromTo.context === context);
                 });
                 if (translation) {
@@ -264,11 +307,10 @@ var FormsAngular = /** @class */ (function () {
         }
         // return a string that determines the sort order of the resultObject
         function calcResultValue(obj) {
-            function padLeft(score, reqLength, str) {
-                if (str === void 0) { str = '0'; }
+            function padLeft(score, reqLength, str = '0') {
                 return new Array(1 + reqLength - String(score).length).join(str) + score;
             }
-            var sortString = '';
+            let sortString = '';
             sortString += padLeft(obj.addHits || 9, 1);
             sortString += padLeft(obj.searchImportance || 99, 2);
             sortString += padLeft(obj.weighting || 9999, 4);
@@ -279,9 +321,9 @@ var FormsAngular = /** @class */ (function () {
             filter = JSON.parse(filter);
         }
         // See if we are narrowing down the resources
-        var collectionName;
-        var collectionNameLower;
-        var colonPos = searchFor.indexOf(':');
+        let collectionName;
+        let collectionNameLower;
+        let colonPos = searchFor.indexOf(':');
         switch (colonPos) {
             case -1:
                 // Original behaviour = do nothing different
@@ -298,19 +340,19 @@ var FormsAngular = /** @class */ (function () {
                 }
                 break;
         }
-        for (var i = 0; i < resourceCount; i++) {
-            var resource = resourcesToSearch[i];
-            if (resourceCount === 1 || (resource.options.searchImportance !== false && (!collectionName || collectionName === resource.resourceName || ((_b = (_a = resource.options) === null || _a === void 0 ? void 0 : _a.synonyms) === null || _b === void 0 ? void 0 : _b.find(function (s) { var _a; return ((_a = s.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === collectionNameLower; }))))) {
-                var schema = resource.model.schema;
-                var indexedFields = [];
-                for (var j = 0; j < schema._indexes.length; j++) {
-                    var attributes = schema._indexes[j][0];
-                    var field = Object.keys(attributes)[0];
+        for (let i = 0; i < resourceCount; i++) {
+            let resource = resourcesToSearch[i];
+            if (resourceCount === 1 || (resource.options.searchImportance !== false && (!collectionName || collectionName === resource.resourceName || resource.options?.synonyms?.find(s => s.name?.toLowerCase() === collectionNameLower)))) {
+                let schema = resource.model.schema;
+                let indexedFields = [];
+                for (let j = 0; j < schema._indexes.length; j++) {
+                    let attributes = schema._indexes[j][0];
+                    let field = Object.keys(attributes)[0];
                     if (indexedFields.indexOf(field) === -1) {
                         indexedFields.push(field);
                     }
                 }
-                for (var path in schema.paths) {
+                for (let path in schema.paths) {
                     if (path !== '_id' && schema.paths.hasOwnProperty(path)) {
                         if (schema.paths[path]._index && !schema.paths[path].options.noSearch) {
                             if (indexedFields.indexOf(path) === -1) {
@@ -322,10 +364,10 @@ var FormsAngular = /** @class */ (function () {
                 if (indexedFields.length === 0) {
                     console.log('ERROR: Searching on a collection with no indexes ' + resource.resourceName);
                 }
-                var synonymObj = (_d = (_c = resource.options) === null || _c === void 0 ? void 0 : _c.synonyms) === null || _d === void 0 ? void 0 : _d.find(function (s) { return s.name.toLowerCase() === collectionNameLower; });
-                var synonymFilter = synonymObj === null || synonymObj === void 0 ? void 0 : synonymObj.filter;
-                for (var m = 0; m < indexedFields.length; m++) {
-                    var searchObj = { resource: resource, field: indexedFields[m] };
+                let synonymObj = resource.options?.synonyms?.find(s => s.name.toLowerCase() === collectionNameLower);
+                const synonymFilter = synonymObj?.filter;
+                for (let m = 0; m < indexedFields.length; m++) {
+                    let searchObj = { resource: resource, field: indexedFields[m] };
                     if (synonymFilter) {
                         searchObj.filter = synonymFilter;
                     }
@@ -333,19 +375,19 @@ var FormsAngular = /** @class */ (function () {
                 }
             }
         }
-        var that = this;
-        var results = [];
-        var moreCount = 0;
-        var searchCriteria;
-        var searchStrings;
-        var multiMatchPossible = false;
+        const that = this;
+        let results = [];
+        let moreCount = 0;
+        let searchCriteria;
+        let searchStrings;
+        let multiMatchPossible = false;
         if (searchFor === '?') {
             // interpret this as a wildcard (so there is no way to search for ?
             searchCriteria = null;
         }
         else {
             // Support for searching anywhere in a field by starting with *
-            var startAnchor = '^';
+            let startAnchor = '^';
             if (searchFor.slice(0, 1) === '*') {
                 startAnchor = '';
                 searchFor = searchFor.slice(1);
@@ -356,19 +398,19 @@ var FormsAngular = /** @class */ (function () {
             if (multiMatchPossible) {
                 searchStrings = searchFor.split(' ');
             }
-            var modifiedSearchStr = multiMatchPossible ? searchStrings.join('|') : searchFor;
+            let modifiedSearchStr = multiMatchPossible ? searchStrings.join('|') : searchFor;
             searchFor = searchFor.toLowerCase(); // For later case-insensitive comparison
             // Removed the logic that preserved spaces when collection was specified because Louise asked me to.
-            searchCriteria = { $regex: "".concat(startAnchor, "(").concat(modifiedSearchStr, ")"), $options: 'i' };
+            searchCriteria = { $regex: `${startAnchor}(${modifiedSearchStr})`, $options: 'i' };
         }
-        var handleSearchResultsFromIndex = function (err, docs, item, cb) {
+        let handleSearchResultsFromIndex = function (err, docs, item, cb) {
             function handleSingleSearchResult(aDoc, cbdoc) {
-                var thisId = aDoc._id.toString(), resultObject, resultPos;
+                let thisId = aDoc._id.toString(), resultObject, resultPos;
                 function handleResultsInList() {
                     if (multiMatchPossible) {
                         resultObject.matched = resultObject.matched || [];
                         // record the index of string that matched, so we don't count it against another field
-                        for (var i = 0; i < searchStrings.length; i++) {
+                        for (let i = 0; i < searchStrings.length; i++) {
                             if (aDoc[item.field].toLowerCase().indexOf(searchStrings[i]) === 0) {
                                 resultObject.matched.push(i);
                                 break;
@@ -395,7 +437,7 @@ var FormsAngular = /** @class */ (function () {
                     // If they have already matched then improve their weighting
                     if (multiMatchPossible) {
                         // record the index of string that matched, so we don't count it against another field
-                        for (var i = 0; i < searchStrings.length; i++) {
+                        for (let i = 0; i < searchStrings.length; i++) {
                             if (!resultObject.matched.includes(i) && aDoc[item.field].toLowerCase().indexOf(searchStrings[i]) === 0) {
                                 resultObject.matched.push(i);
                                 resultObject.addHits = Math.max((resultObject.addHits || 9) - 1, 0);
@@ -411,19 +453,28 @@ var FormsAngular = /** @class */ (function () {
                 }
                 else {
                     // Otherwise add them new...
-                    var addHits_1;
-                    if (multiMatchPossible)
+                    let addHits;
+                    if (multiMatchPossible) {
                         // If they match the whole search phrase in one index they get smaller addHits (so they sort higher)
                         if (aDoc[item.field].toLowerCase().indexOf(searchFor) === 0) {
-                            addHits_1 = 7;
+                            addHits = 7;
                         }
+                    }
+                    let disambiguationId;
+                    const opts = item.resource.options;
+                    const disambiguationResource = opts.disambiguation?.resource;
+                    if (disambiguationResource) {
+                        disambiguationId = aDoc[opts.disambiguation.field]?.toString();
+                    }
                     // Use special listings format if defined
-                    var specialListingFormat = item.resource.options.searchResultFormat;
+                    let specialListingFormat = item.resource.options.searchResultFormat;
                     if (specialListingFormat) {
                         specialListingFormat.apply(aDoc, [req])
-                            .then(function (resultObj) {
+                            .then((resultObj) => {
                             resultObject = resultObj;
-                            resultObject.addHits = addHits_1;
+                            resultObject.addHits = addHits;
+                            resultObject.disambiguationResource = disambiguationResource;
+                            resultObject.disambiguationId = disambiguationId;
                             handleResultsInList();
                         });
                     }
@@ -436,7 +487,9 @@ var FormsAngular = /** @class */ (function () {
                                 resultObject = {
                                     id: aDoc._id,
                                     weighting: 9999,
-                                    addHits: addHits_1,
+                                    addHits,
+                                    disambiguationResource,
+                                    disambiguationId,
                                     text: description
                                 };
                                 if (resourceCount > 1 || includeResourceInResults) {
@@ -456,14 +509,14 @@ var FormsAngular = /** @class */ (function () {
             }
         };
         this.searchFunc(searches, function (item, cb) {
-            var searchDoc = {};
-            var searchFilter = filter || item.filter;
+            let searchDoc = {};
+            let searchFilter = filter || item.filter;
             if (searchFilter) {
                 that.hackVariables(searchFilter);
                 extend(searchDoc, searchFilter);
                 if (searchFilter[item.field]) {
                     delete searchDoc[item.field];
-                    var obj1 = {}, obj2 = {};
+                    let obj1 = {}, obj2 = {};
                     obj1[item.field] = searchFilter[item.field];
                     obj2[item.field] = searchCriteria;
                     searchDoc['$and'] = [obj1, obj2];
@@ -512,13 +565,27 @@ var FormsAngular = /** @class */ (function () {
                     moreCount += results.length - limit;
                     results.splice(limit);
                 }
-                timestamps.completedAt = new Date().valueOf();
-                callback(null, { results: results, moreCount: moreCount, timestamps: timestamps });
+                that.disambiguate(results, that.buildMultiResourceAmbiguousRecordStore(results, ["text"], "disambiguationResource"), "disambiguationId", (item, disambiguationText) => {
+                    item.text += ` (${disambiguationText})`;
+                }, (err) => {
+                    if (err) {
+                        callback(err);
+                    }
+                    else {
+                        // the disambiguate() call will have deleted the disambiguationIds but we're responsible for
+                        // the disambiguationResources, which we shouldn't be returning to the client
+                        for (const result of results) {
+                            delete result.disambiguationResource;
+                        }
+                        timestamps.completedAt = new Date().valueOf();
+                        callback(null, { results, moreCount, timestamps });
+                    }
+                });
             }
         });
-    };
+    }
     ;
-    FormsAngular.prototype.wrapInternalSearch = function (req, res, resourcesToSearch, includeResourceInResults, limit) {
+    wrapInternalSearch(req, res, resourcesToSearch, includeResourceInResults, limit) {
         this.internalSearch(req, resourcesToSearch, includeResourceInResults, limit, function (err, resultsObject) {
             if (err) {
                 res.status(400, err);
@@ -527,46 +594,46 @@ var FormsAngular = /** @class */ (function () {
                 res.send(resultsObject);
             }
         });
-    };
+    }
     ;
-    FormsAngular.prototype.search = function () {
+    search() {
         return _.bind(function (req, res, next) {
             if (!(req.resource = this.getResource(req.params.resourceName))) {
                 return next();
             }
             this.wrapInternalSearch(req, res, [req.resource], false, 0);
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.searchAll = function () {
+    searchAll() {
         return _.bind(function (req, res) {
             this.wrapInternalSearch(req, res, this.resources, true, 10);
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.models = function () {
-        var that = this;
+    models() {
+        const that = this;
         return function (req, res) {
             //    TODO: Make this less wasteful - we only need to send the resourceNames of the resources
             // Check for optional modelFilter and call it with the request and current list.  Otherwise just return the list.
             res.send(that.options.modelFilter ? that.options.modelFilter.call(null, req, that.resources) : that.resources);
         };
-    };
+    }
     ;
-    FormsAngular.prototype.renderError = function (err, redirectUrl, req, res) {
-        res.statusMessage = (err === null || err === void 0 ? void 0 : err.message) || err;
-        res.status(400).end((err === null || err === void 0 ? void 0 : err.message) || err);
-    };
+    renderError(err, redirectUrl, req, res) {
+        res.statusMessage = err?.message || err;
+        res.status(400).end(err?.message || err);
+    }
     ;
-    FormsAngular.prototype.redirect = function (address, req, res) {
+    redirect(address, req, res) {
         res.send(address);
-    };
+    }
     ;
-    FormsAngular.prototype.applySchemaSubset = function (vanilla, schema) {
-        var outPath;
+    applySchemaSubset(vanilla, schema) {
+        let outPath;
         if (schema) {
             outPath = {};
-            for (var fld in schema) {
+            for (let fld in schema) {
                 if (schema.hasOwnProperty(fld)) {
                     if (vanilla[fld]) {
                         outPath[fld] = _.cloneDeep(vanilla[fld]);
@@ -586,7 +653,7 @@ var FormsAngular = /** @class */ (function () {
                         }
                     }
                     outPath[fld].options = outPath[fld].options || {};
-                    for (var override in schema[fld]) {
+                    for (const override in schema[fld]) {
                         if (schema[fld].hasOwnProperty(override)) {
                             if (override.slice(0, 1) !== '_') {
                                 if (schema[fld].hasOwnProperty(override)) {
@@ -605,19 +672,19 @@ var FormsAngular = /** @class */ (function () {
             outPath = vanilla;
         }
         return outPath;
-    };
+    }
     ;
-    FormsAngular.prototype.preprocess = function (resource, paths, formSchema) {
-        var outPath = {}, hiddenFields = [], listFields = [];
+    preprocess(resource, paths, formSchema) {
+        let outPath = {}, hiddenFields = [], listFields = [];
         if (resource && resource.options && resource.options.idIsList) {
             paths['_id'].options = paths['_id'].options || {};
             paths['_id'].options.list = resource.options.idIsList;
         }
-        for (var element in paths) {
+        for (let element in paths) {
             if (paths.hasOwnProperty(element) && element !== '__v') {
                 // check for schemas
                 if (paths[element].schema) {
-                    var subSchemaInfo = this.preprocess(null, paths[element].schema.paths);
+                    let subSchemaInfo = this.preprocess(null, paths[element].schema.paths);
                     outPath[element] = { schema: subSchemaInfo.paths };
                     if (paths[element].options.form) {
                         outPath[element].options = { form: extend(true, {}, paths[element].options.form) };
@@ -631,10 +698,10 @@ var FormsAngular = /** @class */ (function () {
                 }
                 else {
                     // check for arrays
-                    var realType = paths[element].caster ? paths[element].caster : paths[element];
+                    let realType = paths[element].caster ? paths[element].caster : paths[element];
                     if (!realType.instance) {
                         if (realType.options.type) {
-                            var type = realType.options.type(), typeType = typeof type;
+                            let type = realType.options.type(), typeType = typeof type;
                             if (typeType === 'string') {
                                 realType.instance = (!isNaN(Date.parse(type))) ? 'Date' : 'String';
                             }
@@ -650,9 +717,9 @@ var FormsAngular = /** @class */ (function () {
                     if (paths[element].options.match) {
                         outPath[element].options.match = paths[element].options.match.source || paths[element].options.match;
                     }
-                    var schemaListInfo = paths[element].options.list;
+                    let schemaListInfo = paths[element].options.list;
                     if (schemaListInfo) {
-                        var listFieldInfo = { field: element };
+                        let listFieldInfo = { field: element };
                         if (typeof schemaListInfo === 'object' && Object.keys(schemaListInfo).length > 0) {
                             listFieldInfo.params = schemaListInfo;
                         }
@@ -662,7 +729,7 @@ var FormsAngular = /** @class */ (function () {
             }
         }
         outPath = this.applySchemaSubset(outPath, formSchema);
-        var returnObj = { paths: outPath };
+        let returnObj = { paths: outPath };
         if (hiddenFields.length > 0) {
             returnObj.hide = hiddenFields;
         }
@@ -670,113 +737,101 @@ var FormsAngular = /** @class */ (function () {
             returnObj.listFields = listFields;
         }
         return returnObj;
-    };
+    }
     ;
-    FormsAngular.prototype.schema = function () {
+    schema() {
         return _.bind(function (req, res) {
             if (!(req.resource = this.getResource(req.params.resourceName))) {
                 return res.status(404).end();
             }
-            var formSchema = null;
+            let formSchema = null;
             if (req.params.formName) {
                 formSchema = req.resource.model.schema.statics['form'](req.params.formName, req);
             }
-            var paths = this.preprocess(req.resource, req.resource.model.schema.paths, formSchema).paths;
+            let paths = this.preprocess(req.resource, req.resource.model.schema.paths, formSchema).paths;
             res.send(paths);
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.report = function () {
-        return _.bind(function (req, res, next) {
-            return __awaiter(this, void 0, void 0, function () {
-                var self, reportSchema, fields, key, schemaCopy;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!(req.resource = this.getResource(req.params.resourceName))) {
-                                return [2 /*return*/, next()];
-                            }
-                            self = this;
-                            if (typeof req.query === 'undefined') {
-                                req.query = {};
-                            }
-                            if (!req.params.reportName) return [3 /*break*/, 2];
-                            return [4 /*yield*/, req.resource.model.schema.statics['report'](req.params.reportName, req)];
-                        case 1:
-                            reportSchema = _a.sent();
-                            return [3 /*break*/, 3];
-                        case 2:
-                            if (req.query.r) {
-                                switch (req.query.r[0]) {
-                                    case '[':
-                                        reportSchema = { pipeline: JSON.parse(req.query.r) };
-                                        break;
-                                    case '{':
-                                        reportSchema = JSON.parse(req.query.r);
-                                        break;
-                                    default:
-                                        return [2 /*return*/, self.renderError(new Error('Invalid "r" parameter'), null, req, res)];
-                                }
-                            }
-                            else {
-                                fields = {};
-                                for (key in req.resource.model.schema.paths) {
-                                    if (req.resource.model.schema.paths.hasOwnProperty(key)) {
-                                        if (key !== '__v' && !req.resource.model.schema.paths[key].options.secure) {
-                                            if (key.indexOf('.') === -1) {
-                                                fields[key] = 1;
-                                            }
-                                        }
-                                    }
-                                }
-                                reportSchema = {
-                                    pipeline: [
-                                        { $project: fields }
-                                    ], drilldown: req.params.resourceName + '/|_id|/edit'
-                                };
+    report() {
+        return _.bind(async function (req, res, next) {
+            if (!(req.resource = this.getResource(req.params.resourceName))) {
+                return next();
+            }
+            const self = this;
+            if (typeof req.query === 'undefined') {
+                req.query = {};
+            }
+            let reportSchema;
+            if (req.params.reportName) {
+                reportSchema = await req.resource.model.schema.statics['report'](req.params.reportName, req);
+            }
+            else if (req.query.r) {
+                switch (req.query.r[0]) {
+                    case '[':
+                        reportSchema = { pipeline: JSON.parse(req.query.r) };
+                        break;
+                    case '{':
+                        reportSchema = JSON.parse(req.query.r);
+                        break;
+                    default:
+                        return self.renderError(new Error('Invalid "r" parameter'), null, req, res);
+                }
+            }
+            else {
+                let fields = {};
+                for (let key in req.resource.model.schema.paths) {
+                    if (req.resource.model.schema.paths.hasOwnProperty(key)) {
+                        if (key !== '__v' && !req.resource.model.schema.paths[key].options.secure) {
+                            if (key.indexOf('.') === -1) {
+                                fields[key] = 1;
                             }
-                            _a.label = 3;
-                        case 3:
-                            schemaCopy = {};
-                            extend(schemaCopy, reportSchema);
-                            schemaCopy.params = schemaCopy.params || [];
-                            self.reportInternal(req, req.resource, schemaCopy, function (err, result) {
-                                if (err) {
-                                    res.send({ success: false, error: err.message || err });
-                                }
-                                else {
-                                    res.send(result);
-                                }
-                            });
-                            return [2 /*return*/];
+                        }
                     }
-                });
+                }
+                reportSchema = {
+                    pipeline: [
+                        { $project: fields }
+                    ], drilldown: req.params.resourceName + '/|_id|/edit'
+                };
+            }
+            // Replace parameters in pipeline
+            let schemaCopy = {};
+            extend(schemaCopy, reportSchema);
+            schemaCopy.params = schemaCopy.params || [];
+            self.reportInternal(req, req.resource, schemaCopy, function (err, result) {
+                if (err) {
+                    res.send({ success: false, error: err.message || err });
+                }
+                else {
+                    res.send(result);
+                }
             });
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.hackVariablesInPipeline = function (runPipeline) {
-        for (var pipelineSection = 0; pipelineSection < runPipeline.length; pipelineSection++) {
+    hackVariablesInPipeline(runPipeline) {
+        for (let pipelineSection = 0; pipelineSection < runPipeline.length; pipelineSection++) {
             if (runPipeline[pipelineSection]['$match']) {
                 this.hackVariables(runPipeline[pipelineSection]['$match']);
             }
         }
-    };
+    }
     ;
-    FormsAngular.prototype.hackVariables = function (obj) {
+    hackVariables(obj) {
         // Replace variables that cannot be serialised / deserialised.  Bit of a hack, but needs must...
         // Anything formatted 1800-01-01T00:00:00.000Z or 1800-01-01T00:00:00.000+0000 is converted to a Date
         // Only handles the cases I need for now
         // TODO: handle arrays etc
-        for (var prop in obj) {
+        for (const prop in obj) {
             if (obj.hasOwnProperty(prop)) {
                 if (typeof obj[prop] === 'string') {
-                    var dateTest = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3})(Z|[+ -]\d{4})$/.exec(obj[prop]);
+                    const dateTest = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3})(Z|[+ -]\d{4})$/.exec(obj[prop]);
                     if (dateTest) {
                         obj[prop] = new Date(dateTest[1] + 'Z');
                     }
                     else {
-                        var objectIdTest = /^([0-9a-fA-F]{24})$/.exec(obj[prop]);
+                        const objectIdTest = /^([0-9a-fA-F]{24})$/.exec(obj[prop]);
                         if (objectIdTest) {
                             obj[prop] = new this.mongoose.Types.ObjectId(objectIdTest[1]);
                         }
@@ -787,20 +842,19 @@ var FormsAngular = /** @class */ (function () {
                 }
             }
         }
-    };
+    }
     ;
-    FormsAngular.prototype.sanitisePipeline = function (aggregationParam, hiddenFields, findFuncQry) {
-        var _a, _b, _c, _d;
-        var that = this;
-        var array = Array.isArray(aggregationParam) ? aggregationParam : [aggregationParam];
-        var retVal = [];
-        var doneHiddenFields = false;
+    sanitisePipeline(aggregationParam, hiddenFields, findFuncQry) {
+        let that = this;
+        let array = Array.isArray(aggregationParam) ? aggregationParam : [aggregationParam];
+        let retVal = [];
+        let doneHiddenFields = false;
         if (findFuncQry) {
             retVal.unshift({ $match: findFuncQry });
         }
-        var _loop_1 = function (pipelineSection) {
-            var stage = array[pipelineSection];
-            var keys = Object.keys(stage);
+        for (let pipelineSection = 0; pipelineSection < array.length; pipelineSection++) {
+            let stage = array[pipelineSection];
+            let keys = Object.keys(stage);
             if (keys.length !== 1) {
                 throw new Error('Invalid pipeline instruction');
             }
@@ -812,18 +866,18 @@ var FormsAngular = /** @class */ (function () {
                     /*
                         Sanitise the pipeline we are doing a union with, removing hidden fields from that collection
                      */
-                    var unionCollectionName = stage.$unionWith.coll;
-                    var unionResource = that.getResourceFromCollection(unionCollectionName);
-                    var unionHiddenLookupFields = {};
+                    const unionCollectionName = stage.$unionWith.coll;
+                    const unionResource = that.getResourceFromCollection(unionCollectionName);
+                    let unionHiddenLookupFields = {};
                     if (unionResource) {
-                        if (((_b = (_a = unionResource.options) === null || _a === void 0 ? void 0 : _a.hide) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                            unionHiddenLookupFields = this_1.generateHiddenFields(unionResource, false);
+                        if (unionResource.options?.hide?.length > 0) {
+                            unionHiddenLookupFields = this.generateHiddenFields(unionResource, false);
                         }
                     }
                     stage.$unionWith.pipeline = that.sanitisePipeline(stage.$unionWith.pipeline, unionHiddenLookupFields, findFuncQry);
                     break;
                 case '$match':
-                    this_1.hackVariables(array[pipelineSection]['$match']);
+                    this.hackVariables(array[pipelineSection]['$match']);
                     retVal.push(array[pipelineSection]);
                     if (!doneHiddenFields && Object.keys(hiddenFields) && Object.keys(hiddenFields).length > 0) {
                         // We can now project out the hidden fields (we wait for the $match to make sure we don't break
@@ -835,20 +889,20 @@ var FormsAngular = /** @class */ (function () {
                     break;
                 case '$lookup':
                     // hide any hiddenfields in the lookup collection
-                    var collectionName = stage.$lookup.from;
-                    var lookupField_1 = stage.$lookup.as;
-                    if ((collectionName + lookupField_1).indexOf('$') !== -1) {
+                    const collectionName = stage.$lookup.from;
+                    const lookupField = stage.$lookup.as;
+                    if ((collectionName + lookupField).indexOf('$') !== -1) {
                         throw new Error('No support for lookups where the "from" or "as" is anything other than a simple string');
                     }
-                    var resource = that.getResourceFromCollection(collectionName);
+                    const resource = that.getResourceFromCollection(collectionName);
                     if (resource) {
-                        if (((_d = (_c = resource.options) === null || _c === void 0 ? void 0 : _c.hide) === null || _d === void 0 ? void 0 : _d.length) > 0) {
-                            var hiddenLookupFields = this_1.generateHiddenFields(resource, false);
-                            var hiddenFieldsObj_1 = {};
-                            Object.keys(hiddenLookupFields).forEach(function (hf) {
-                                hiddenFieldsObj_1["".concat(lookupField_1, ".").concat(hf)] = false;
+                        if (resource.options?.hide?.length > 0) {
+                            const hiddenLookupFields = this.generateHiddenFields(resource, false);
+                            let hiddenFieldsObj = {};
+                            Object.keys(hiddenLookupFields).forEach(hf => {
+                                hiddenFieldsObj[`${lookupField}.${hf}`] = false;
                             });
-                            retVal.push({ $project: hiddenFieldsObj_1 });
+                            retVal.push({ $project: hiddenFieldsObj });
                         }
                     }
                     break;
@@ -859,21 +913,17 @@ var FormsAngular = /** @class */ (function () {
             if (stage) {
                 retVal.push(stage);
             }
-        };
-        var this_1 = this;
-        for (var pipelineSection = 0; pipelineSection < array.length; pipelineSection++) {
-            _loop_1(pipelineSection);
         }
         if (!doneHiddenFields && Object.keys(hiddenFields) && Object.keys(hiddenFields).length > 0) {
             // If there was no $match we still need to hide the hidden fields
             retVal.unshift({ $project: hiddenFields });
         }
         return retVal;
-    };
-    FormsAngular.prototype.reportInternal = function (req, resource, schema, callback) {
-        var runPipelineStr;
-        var runPipelineObj;
-        var self = this;
+    }
+    reportInternal(req, resource, schema, callback) {
+        let runPipelineStr;
+        let runPipelineObj;
+        let self = this;
         if (typeof req.query === 'undefined') {
             req.query = {};
         }
@@ -883,7 +933,7 @@ var FormsAngular = /** @class */ (function () {
             }
             else {
                 runPipelineStr = JSON.stringify(schema.pipeline);
-                for (var param in req.query) {
+                for (let param in req.query) {
                     if (req.query.hasOwnProperty(param)) {
                         if (req.query[param]) {
                             if (param !== 'r') { // we don't want to copy the whole report schema (again!)
@@ -891,7 +941,7 @@ var FormsAngular = /** @class */ (function () {
                                     schema.params[param].value = req.query[param];
                                 }
                                 else {
-                                    callback("No such parameter as ".concat(param, " - try one of ").concat(Object.keys(schema.params).join()));
+                                    callback(`No such parameter as ${param} - try one of ${Object.keys(schema.params).join()}`);
                                 }
                             }
                         }
@@ -900,7 +950,7 @@ var FormsAngular = /** @class */ (function () {
                 // Replace parameters with the value
                 if (runPipelineStr) {
                     runPipelineStr = runPipelineStr.replace(/"\(.+?\)"/g, function (match) {
-                        var sparam = schema.params[match.slice(2, -2)];
+                        let sparam = schema.params[match.slice(2, -2)];
                         if (sparam !== undefined) {
                             if (sparam.type === 'number') {
                                 return sparam.value;
@@ -916,27 +966,27 @@ var FormsAngular = /** @class */ (function () {
                             }
                         }
                         else {
-                            callback("No such parameter as ".concat(match.slice(2, -2), " - try one of ").concat(Object.keys(schema.params).join()));
+                            callback(`No such parameter as ${match.slice(2, -2)} - try one of ${Object.keys(schema.params).join()}`);
                         }
                     });
                 }
                 runPipelineObj = JSON.parse(runPipelineStr);
-                var hiddenFields_1 = self.generateHiddenFields(resource, false);
-                var toDo = {
+                let hiddenFields = self.generateHiddenFields(resource, false);
+                let toDo = {
                     runAggregation: function (cb) {
-                        runPipelineObj = self.sanitisePipeline(runPipelineObj, hiddenFields_1, queryObj);
+                        runPipelineObj = self.sanitisePipeline(runPipelineObj, hiddenFields, queryObj);
                         resource.model.aggregate(runPipelineObj, cb);
                     }
                 };
-                var translations_1 = []; // array of form {ref:'lookupname',translations:[{value:xx, display:'  '}]}
+                let translations = []; // array of form {ref:'lookupname',translations:[{value:xx, display:'  '}]}
                 // if we need to do any column translations add the function to the tasks list
                 if (schema.columnTranslations) {
                     toDo.applyTranslations = ['runAggregation', function (results, cb) {
                             function doATranslate(column, theTranslation) {
                                 results['runAggregation'].forEach(function (resultRow) {
-                                    var valToTranslate = resultRow[column.field];
+                                    let valToTranslate = resultRow[column.field];
                                     valToTranslate = (valToTranslate ? valToTranslate.toString() : '');
-                                    var thisTranslation = _.find(theTranslation.translations, function (option) {
+                                    let thisTranslation = _.find(theTranslation.translations, function (option) {
                                         return valToTranslate === option.value.toString();
                                     });
                                     resultRow[column.field] = thisTranslation ? thisTranslation.display : ' * Missing columnTranslation * ';
@@ -947,7 +997,7 @@ var FormsAngular = /** @class */ (function () {
                                     doATranslate(columnTranslation, columnTranslation);
                                 }
                                 if (columnTranslation.ref) {
-                                    var theTranslation = _.find(translations_1, function (translation) {
+                                    let theTranslation = _.find(translations, function (translation) {
                                         return (translation.ref === columnTranslation.ref);
                                     });
                                     if (theTranslation) {
@@ -960,9 +1010,9 @@ var FormsAngular = /** @class */ (function () {
                             });
                             cb(null, null);
                         }];
-                    var callFuncs = false;
-                    for (var i = 0; i < schema.columnTranslations.length; i++) {
-                        var thisColumnTranslation = schema.columnTranslations[i];
+                    let callFuncs = false;
+                    for (let i = 0; i < schema.columnTranslations.length; i++) {
+                        let thisColumnTranslation = schema.columnTranslations[i];
                         if (thisColumnTranslation.field) {
                             // if any of the column translations are adhoc funcs, set up the tasks to perform them
                             if (thisColumnTranslation.fn) {
@@ -970,28 +1020,28 @@ var FormsAngular = /** @class */ (function () {
                             }
                             // if this column translation is a "ref", set up the tasks to look up the values and populate the translations
                             if (thisColumnTranslation.ref) {
-                                var lookup = self.getResource(thisColumnTranslation.ref);
+                                let lookup = self.getResource(thisColumnTranslation.ref);
                                 if (lookup) {
                                     if (!toDo[thisColumnTranslation.ref]) {
-                                        var getFunc = function (ref) {
-                                            var lookup = ref;
+                                        let getFunc = function (ref) {
+                                            let lookup = ref;
                                             return function (cb) {
-                                                var translateObject = { ref: lookup.resourceName, translations: [] };
-                                                translations_1.push(translateObject);
+                                                let translateObject = { ref: lookup.resourceName, translations: [] };
+                                                translations.push(translateObject);
                                                 lookup.model.find({}, {}, { lean: true }, function (err, findResults) {
                                                     if (err) {
                                                         cb(err);
                                                     }
                                                     else {
                                                         // TODO - this ref func can probably be done away with now that list fields can have ref
-                                                        var j_1 = 0;
+                                                        let j = 0;
                                                         async.whilst(function (cbtest) {
-                                                            cbtest(null, j_1 < findResults.length);
+                                                            cbtest(null, j < findResults.length);
                                                         }, function (cbres) {
-                                                            var theResult = findResults[j_1];
-                                                            translateObject.translations[j_1] = translateObject.translations[j_1] || {};
-                                                            var theTranslation = translateObject.translations[j_1];
-                                                            j_1++;
+                                                            let theResult = findResults[j];
+                                                            translateObject.translations[j] = translateObject.translations[j] || {};
+                                                            let theTranslation = translateObject.translations[j];
+                                                            j++;
                                                             self.getListFields(lookup, theResult, function (err, description) {
                                                                 if (err) {
                                                                     cbres(err);
@@ -1026,8 +1076,8 @@ var FormsAngular = /** @class */ (function () {
                     if (callFuncs) {
                         toDo['callFunctions'] = ['runAggregation', function (results, cb) {
                                 async.each(results.runAggregation, function (row, cb) {
-                                    for (var i = 0; i < schema.columnTranslations.length; i++) {
-                                        var thisColumnTranslation = schema.columnTranslations[i];
+                                    for (let i = 0; i < schema.columnTranslations.length; i++) {
+                                        let thisColumnTranslation = schema.columnTranslations[i];
                                         if (thisColumnTranslation.fn) {
                                             thisColumnTranslation.fn(row, cb);
                                         }
@@ -1055,13 +1105,13 @@ var FormsAngular = /** @class */ (function () {
                 });
             }
         });
-    };
+    }
     ;
-    FormsAngular.prototype.saveAndRespond = function (req, res, hiddenFields) {
+    saveAndRespond(req, res, hiddenFields) {
         function internalSave(doc) {
             doc.save(function (err, doc2) {
                 if (err) {
-                    var err2 = { status: 'err' };
+                    let err2 = { status: 'err' };
                     if (!err.errors) {
                         err2.message = err.message;
                     }
@@ -1075,12 +1125,12 @@ var FormsAngular = /** @class */ (function () {
                 }
                 else {
                     doc2 = doc2.toObject();
-                    for (var hiddenField in hiddenFields) {
+                    for (const hiddenField in hiddenFields) {
                         if (hiddenFields.hasOwnProperty(hiddenField) && hiddenFields[hiddenField]) {
-                            var parts = hiddenField.split('.');
-                            var lastPart = parts.length - 1;
-                            var target = doc2;
-                            for (var i = 0; i < lastPart; i++) {
+                            let parts = hiddenField.split('.');
+                            let lastPart = parts.length - 1;
+                            let target = doc2;
+                            for (let i = 0; i < lastPart; i++) {
                                 if (target.hasOwnProperty(parts[i])) {
                                     target = target[parts[i]];
                                 }
@@ -1094,7 +1144,7 @@ var FormsAngular = /** @class */ (function () {
                 }
             });
         }
-        var doc = req.doc;
+        let doc = req.doc;
         if (typeof req.resource.options.onSave === 'function') {
             req.resource.options.onSave(doc, req, function (err) {
                 if (err) {
@@ -1106,19 +1156,19 @@ var FormsAngular = /** @class */ (function () {
         else {
             internalSave(doc);
         }
-    };
+    }
     ;
     /**
      * All entities REST functions have to go through this first.
      */
-    FormsAngular.prototype.processCollection = function (req) {
+    processCollection(req) {
         req.resource = this.getResource(req.params.resourceName);
-    };
+    }
     ;
     /**
      * Renders a view with the list of docs, which may be modified by query parameters
      */
-    FormsAngular.prototype.collectionGet = function () {
+    collectionGet() {
         return _.bind(function (req, res, next) {
             this.processCollection(req);
             if (!req.resource) {
@@ -1128,20 +1178,20 @@ var FormsAngular = /** @class */ (function () {
                 req.query = {};
             }
             try {
-                var aggregationParam = req.query.a ? JSON.parse(req.query.a) : null;
-                var findParam = req.query.f ? JSON.parse(req.query.f) : {};
-                var projectParam = req.query.p ? JSON.parse(req.query.p) : {};
-                var limitParam = req.query.l ? JSON.parse(req.query.l) : 0;
-                var skipParam = req.query.s ? JSON.parse(req.query.s) : 0;
-                var orderParam = req.query.o ? JSON.parse(req.query.o) : req.resource.options.listOrder;
+                const aggregationParam = req.query.a ? JSON.parse(req.query.a) : null;
+                const findParam = req.query.f ? JSON.parse(req.query.f) : {};
+                const projectParam = req.query.p ? JSON.parse(req.query.p) : {};
+                const limitParam = req.query.l ? JSON.parse(req.query.l) : 0;
+                const skipParam = req.query.s ? JSON.parse(req.query.s) : 0;
+                const orderParam = req.query.o ? JSON.parse(req.query.o) : req.resource.options.listOrder;
                 // Dates in aggregation must be Dates
                 if (aggregationParam) {
                     this.hackVariablesInPipeline(aggregationParam);
                 }
-                var self_1 = this;
+                const self = this;
                 this.filteredFind(req.resource, req, aggregationParam, findParam, projectParam, orderParam, limitParam, skipParam, function (err, docs) {
                     if (err) {
-                        return self_1.renderError(err, null, req, res);
+                        return self.renderError(err, null, req, res);
                     }
                     else {
                         res.send(docs);
@@ -1152,10 +1202,10 @@ var FormsAngular = /** @class */ (function () {
                 res.status(400).send(e.message);
             }
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.generateProjection = function (hiddenFields, projectParam) {
-        var type;
+    generateProjection(hiddenFields, projectParam) {
+        let type;
         function setSelectType(typeChar, checkChar) {
             if (type === checkChar) {
                 throw new Error('Cannot mix include and exclude fields in select');
@@ -1164,11 +1214,11 @@ var FormsAngular = /** @class */ (function () {
                 type = typeChar;
             }
         }
-        var retVal = hiddenFields;
+        let retVal = hiddenFields;
         if (projectParam) {
-            var projection = Object.keys(projectParam);
+            let projection = Object.keys(projectParam);
             if (projection.length > 0) {
-                projection.forEach(function (p) {
+                projection.forEach(p => {
                     if (projectParam[p] === 0) {
                         setSelectType('E', 'I');
                     }
@@ -1186,7 +1236,7 @@ var FormsAngular = /** @class */ (function () {
                 else {
                     // We are selecting fields - make sure none are hidden
                     retVal = projectParam;
-                    for (var h in hiddenFields) {
+                    for (let h in hiddenFields) {
                         if (hiddenFields.hasOwnProperty(h)) {
                             delete retVal[h];
                         }
@@ -1195,21 +1245,21 @@ var FormsAngular = /** @class */ (function () {
             }
         }
         return retVal;
-    };
+    }
     ;
-    FormsAngular.prototype.doFindFunc = function (req, resource, cb) {
+    doFindFunc(req, resource, cb) {
         if (resource.options.findFunc) {
             resource.options.findFunc(req, cb);
         }
         else {
             cb(null);
         }
-    };
+    }
     ;
-    FormsAngular.prototype.filteredFind = function (resource, req, aggregationParam, findParam, projectParam, sortOrder, limit, skip, callback) {
-        var that = this;
-        var hiddenFields = this.generateHiddenFields(resource, false);
-        var stashAggregationResults;
+    filteredFind(resource, req, aggregationParam, findParam, projectParam, sortOrder, limit, skip, callback) {
+        const that = this;
+        let hiddenFields = this.generateHiddenFields(resource, false);
+        let stashAggregationResults;
         function doAggregation(queryObj, cb) {
             if (aggregationParam) {
                 aggregationParam = that.sanitisePipeline(aggregationParam, hiddenFields, queryObj);
@@ -1239,7 +1289,7 @@ var FormsAngular = /** @class */ (function () {
                         callback(null, []);
                     }
                     else {
-                        var query = resource.model.find(queryObj);
+                        let query = resource.model.find(queryObj);
                         if (idArray.length > 0) {
                             query = query.where('_id').in(idArray);
                         }
@@ -1258,10 +1308,10 @@ var FormsAngular = /** @class */ (function () {
                         }
                         query.exec(function (err, docs) {
                             if (!err && stashAggregationResults) {
-                                docs.forEach(function (obj) {
+                                docs.forEach(obj => {
                                     // Add any fields from the aggregation results whose field name starts __ to the mongoose Document
-                                    var aggObj = stashAggregationResults.find(function (a) { return a._id.toString() === obj._id.toString(); });
-                                    Object.keys(aggObj).forEach(function (k) {
+                                    let aggObj = stashAggregationResults.find(a => a._id.toString() === obj._id.toString());
+                                    Object.keys(aggObj).forEach(k => {
                                         if (k.slice(0, 2) === '__') {
                                             obj[k] = aggObj[k];
                                         }
@@ -1274,9 +1324,9 @@ var FormsAngular = /** @class */ (function () {
                 });
             }
         });
-    };
+    }
     ;
-    FormsAngular.prototype.collectionPost = function () {
+    collectionPost() {
         return _.bind(function (req, res, next) {
             this.processCollection(req);
             if (!req.resource) {
@@ -1286,36 +1336,36 @@ var FormsAngular = /** @class */ (function () {
             if (!req.body) {
                 throw new Error('Nothing submitted.');
             }
-            var cleansedBody = this.cleanseRequest(req);
+            let cleansedBody = this.cleanseRequest(req);
             req.doc = new req.resource.model(cleansedBody);
             this.saveAndRespond(req, res);
         }, this);
-    };
+    }
     ;
     /**
      * Generate an object of fields to not expose
      **/
-    FormsAngular.prototype.generateHiddenFields = function (resource, state) {
-        var hiddenFields = {};
+    generateHiddenFields(resource, state) {
+        let hiddenFields = {};
         if (resource.options['hide'] !== undefined) {
             resource.options.hide.forEach(function (dt) {
                 hiddenFields[dt] = state;
             });
         }
         return hiddenFields;
-    };
+    }
     ;
     /** Sec issue
      * Cleanse incoming data to avoid overwrite and POST request forgery
      * (name may seem weird but it was in French, so it is some small improvement!)
      */
-    FormsAngular.prototype.cleanseRequest = function (req) {
-        var reqData = req.body, resource = req.resource;
+    cleanseRequest(req) {
+        let reqData = req.body, resource = req.resource;
         delete reqData.__v; // Don't mess with Mongoose internal field (https://github.com/LearnBoost/mongoose/issues/1933)
         if (typeof resource.options['hide'] === 'undefined') {
             return reqData;
         }
-        var hiddenFields = resource.options.hide;
+        let hiddenFields = resource.options.hide;
         _.each(reqData, function (num, key) {
             _.each(hiddenFields, function (fi) {
                 if (fi === key) {
@@ -1324,20 +1374,19 @@ var FormsAngular = /** @class */ (function () {
             });
         });
         return reqData;
-    };
+    }
     ;
-    FormsAngular.prototype.generateQueryForEntity = function (req, resource, id, cb) {
-        var that = this;
-        var hiddenFields = this.generateHiddenFields(resource, false);
+    generateQueryForEntity(req, resource, id, cb) {
+        let that = this;
+        let hiddenFields = this.generateHiddenFields(resource, false);
         hiddenFields.__v = false;
         that.doFindFunc(req, resource, function (err, queryObj) {
-            var _a;
             if (err) {
                 cb(err);
             }
             else {
-                var idSel = { _id: id };
-                var crit = void 0;
+                const idSel = { _id: id };
+                let crit;
                 if (queryObj) {
                     if (queryObj._id) {
                         crit = { $and: [idSel, { _id: queryObj._id }] };
@@ -1353,16 +1402,16 @@ var FormsAngular = /** @class */ (function () {
                 else {
                     crit = idSel;
                 }
-                cb(null, resource.model.findOne(crit).select(that.generateProjection(hiddenFields, (_a = req.query) === null || _a === void 0 ? void 0 : _a.p)));
+                cb(null, resource.model.findOne(crit).select(that.generateProjection(hiddenFields, req.query?.p)));
             }
         });
-    };
+    }
     ;
     /*
      * Entity request goes here first
      * It retrieves the resource
      */
-    FormsAngular.prototype.processEntity = function (req, res, next) {
+    processEntity(req, res, next) {
         if (!(req.resource = this.getResource(req.params.resourceName))) {
             next();
             return;
@@ -1393,14 +1442,14 @@ var FormsAngular = /** @class */ (function () {
                 });
             }
         });
-    };
+    }
     ;
     /**
      * Gets a single entity
      *
      * @return {Function} The function to use as route
      */
-    FormsAngular.prototype.entityGet = function () {
+    entityGet() {
         return _.bind(function (req, res, next) {
             this.processEntity(req, res, function () {
                 if (!req.resource) {
@@ -1416,10 +1465,10 @@ var FormsAngular = /** @class */ (function () {
                 }
             });
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.replaceHiddenFields = function (record, data) {
-        var self = this;
+    replaceHiddenFields(record, data) {
+        const self = this;
         if (record) {
             record._replacingHiddenFields = true;
             _.each(data, function (value, name) {
@@ -1432,11 +1481,11 @@ var FormsAngular = /** @class */ (function () {
             });
             delete record._replacingHiddenFields;
         }
-    };
+    }
     ;
-    FormsAngular.prototype.entityPut = function () {
+    entityPut() {
         return _.bind(function (req, res, next) {
-            var that = this;
+            const that = this;
             this.processEntity(req, res, function () {
                 if (!req.resource) {
                     next();
@@ -1445,19 +1494,19 @@ var FormsAngular = /** @class */ (function () {
                 if (!req.body) {
                     throw new Error('Nothing submitted.');
                 }
-                var cleansedBody = that.cleanseRequest(req);
+                let cleansedBody = that.cleanseRequest(req);
                 // Merge
-                for (var prop in cleansedBody) {
+                for (let prop in cleansedBody) {
                     if (cleansedBody.hasOwnProperty(prop)) {
                         req.doc.set(prop, cleansedBody[prop] === '' ? undefined : cleansedBody[prop]);
                     }
                 }
                 if (req.resource.options.hide !== undefined) {
-                    var hiddenFields_2 = that.generateHiddenFields(req.resource, true);
-                    hiddenFields_2._id = false;
-                    req.resource.model.findById(req.doc._id, hiddenFields_2, { lean: true }, function (err, data) {
+                    let hiddenFields = that.generateHiddenFields(req.resource, true);
+                    hiddenFields._id = false;
+                    req.resource.model.findById(req.doc._id, hiddenFields, { lean: true }, function (err, data) {
                         that.replaceHiddenFields(req.doc, data);
-                        that.saveAndRespond(req, res, hiddenFields_2);
+                        that.saveAndRespond(req, res, hiddenFields);
                     });
                 }
                 else {
@@ -1465,187 +1514,313 @@ var FormsAngular = /** @class */ (function () {
                 }
             });
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.entityDelete = function () {
-        var that = this;
-        return _.bind(function (req, res, next) {
-            return __awaiter(this, void 0, void 0, function () {
-                function generateDependencyList(resource) {
-                    if (resource.options.dependents === undefined) {
-                        resource.options.dependents = that.resources.reduce(function (acc, r) {
-                            function searchPaths(schema, prefix) {
-                                var fldList = [];
-                                for (var fld in schema.paths) {
-                                    if (schema.paths.hasOwnProperty(fld)) {
-                                        var parts = fld.split('.');
-                                        var schemaType = schema.tree;
-                                        while (parts.length > 0) {
-                                            schemaType = schemaType[parts.shift()];
+    entityDelete() {
+        let that = this;
+        return _.bind(async function (req, res, next) {
+            function generateDependencyList(resource) {
+                if (resource.options.dependents === undefined) {
+                    resource.options.dependents = that.resources.reduce(function (acc, r) {
+                        function searchPaths(schema, prefix) {
+                            var fldList = [];
+                            for (var fld in schema.paths) {
+                                if (schema.paths.hasOwnProperty(fld)) {
+                                    var parts = fld.split('.');
+                                    var schemaType = schema.tree;
+                                    while (parts.length > 0) {
+                                        schemaType = schemaType[parts.shift()];
+                                    }
+                                    if (schemaType.type) {
+                                        if (schemaType.type.name === 'ObjectId' && schemaType.ref === resource.resourceName) {
+                                            fldList.push(prefix + fld);
                                         }
-                                        if (schemaType.type) {
-                                            if (schemaType.type.name === 'ObjectId' && schemaType.ref === resource.resourceName) {
-                                                fldList.push(prefix + fld);
-                                            }
-                                            else if (_.isArray(schemaType.type)) {
-                                                schemaType.type.forEach(function (t) {
-                                                    searchPaths(t, prefix + fld + '.');
-                                                });
-                                            }
+                                        else if (_.isArray(schemaType.type)) {
+                                            schemaType.type.forEach(function (t) {
+                                                searchPaths(t, prefix + fld + '.');
+                                            });
                                         }
                                     }
                                 }
-                                if (fldList.length > 0) {
-                                    acc.push({ resource: r, keys: fldList });
-                                }
                             }
-                            searchPaths(r.model.schema, '');
-                            return acc;
-                        }, []);
-                        for (var pluginName in that.options.plugins) {
-                            var thisPlugin = that.options.plugins[pluginName];
-                            if (thisPlugin.dependencyChecks && thisPlugin.dependencyChecks[resource.resourceName]) {
-                                resource.options.dependents = resource.options.dependents.concat(thisPlugin.dependencyChecks[resource.resourceName]);
+                            if (fldList.length > 0) {
+                                acc.push({ resource: r, keys: fldList });
                             }
                         }
+                        searchPaths(r.model.schema, '');
+                        return acc;
+                    }, []);
+                    for (let pluginName in that.options.plugins) {
+                        let thisPlugin = that.options.plugins[pluginName];
+                        if (thisPlugin.dependencyChecks && thisPlugin.dependencyChecks[resource.resourceName]) {
+                            resource.options.dependents = resource.options.dependents.concat(thisPlugin.dependencyChecks[resource.resourceName]);
+                        }
                     }
                 }
-                function removeDoc(doc, resource) {
-                    return __awaiter(this, void 0, void 0, function () {
-                        var promises_1;
-                        return __generator(this, function (_a) {
-                            switch (resource.options.handleRemove) {
-                                case 'allow':
-                                    // old behaviour - no attempt to maintain data integrity
-                                    return [2 /*return*/, doc.remove()];
-                                case 'cascade':
-                                    generateDependencyList(resource);
-                                    res.status(400).send('"cascade" option not yet supported');
-                                    break;
-                                default:
-                                    generateDependencyList(resource);
-                                    promises_1 = [];
-                                    resource.options.dependents.forEach(function (collection) {
-                                        collection.keys.forEach(function (key) {
-                                            var _a;
-                                            promises_1.push({
-                                                p: collection.resource.model.find((_a = {}, _a[key] = doc._id, _a)).limit(1).exec(),
-                                                collection: collection,
-                                                key: key
-                                            });
-                                        });
-                                    });
-                                    return [2 /*return*/, Promise.all(promises_1.map(function (p) { return p.p; }))
-                                            .then(function (results) {
-                                            results.forEach(function (r, i) {
-                                                if (r.length > 0) {
-                                                    throw new ForeignKeyError(resource.resourceName, promises_1[i].collection.resource.resourceName, promises_1[i].key, r[0]._id);
-                                                }
-                                            });
-                                            return doc.remove();
-                                        })];
-                            }
-                            return [2 /*return*/];
-                        });
-                    });
-                }
-                function runDeletion(doc, resource) {
-                    return __awaiter(this, void 0, void 0, function () {
-                        return __generator(this, function (_a) {
-                            return [2 /*return*/, new Promise(function (resolve) {
-                                    if (resource.options.onRemove) {
-                                        resource.options.onRemove(doc, req, function (err) {
-                                            return __awaiter(this, void 0, void 0, function () {
-                                                return __generator(this, function (_a) {
-                                                    if (err) {
-                                                        throw err;
-                                                    }
-                                                    resolve(removeDoc(doc, resource));
-                                                    return [2 /*return*/];
-                                                });
-                                            });
-                                        });
-                                    }
-                                    else {
-                                        resolve(removeDoc(doc, resource));
-                                    }
-                                })];
+            }
+            async function removeDoc(doc, resource) {
+                switch (resource.options.handleRemove) {
+                    case 'allow':
+                        // old behaviour - no attempt to maintain data integrity
+                        return doc.remove();
+                    case 'cascade':
+                        generateDependencyList(resource);
+                        res.status(400).send('"cascade" option not yet supported');
+                        break;
+                    default:
+                        generateDependencyList(resource);
+                        let promises = [];
+                        resource.options.dependents.forEach(collection => {
+                            collection.keys.forEach(key => {
+                                promises.push({
+                                    p: collection.resource.model.find({ [key]: doc._id }).limit(1).exec(),
+                                    collection,
+                                    key
+                                });
+                            });
                         });
-                    });
-                }
-                return __generator(this, function (_a) {
-                    this.processEntity(req, res, function () {
-                        return __awaiter(this, void 0, void 0, function () {
-                            var doc, e_1;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!req.resource) {
-                                            next();
-                                            return [2 /*return*/];
-                                        }
-                                        doc = req.doc;
-                                        _a.label = 1;
-                                    case 1:
-                                        _a.trys.push([1, 3, , 4]);
-                                        return [4 /*yield*/, runDeletion(doc, req.resource)];
-                                    case 2:
-                                        void (_a.sent());
-                                        res.status(200).send();
-                                        return [3 /*break*/, 4];
-                                    case 3:
-                                        e_1 = _a.sent();
-                                        if (e_1 instanceof ForeignKeyError) {
-                                            res.status(400).send(e_1.message);
-                                        }
-                                        else {
-                                            res.status(500).send(e_1.message);
-                                        }
-                                        return [3 /*break*/, 4];
-                                    case 4: return [2 /*return*/];
+                        return Promise.all(promises.map(p => p.p))
+                            .then((results) => {
+                            results.forEach((r, i) => {
+                                if (r.length > 0) {
+                                    throw new ForeignKeyError(resource.resourceName, promises[i].collection.resource.resourceName, promises[i].key, r[0]._id);
                                 }
                             });
+                            return doc.remove();
                         });
-                    });
-                    return [2 /*return*/];
+                }
+            }
+            async function runDeletion(doc, resource) {
+                return new Promise((resolve) => {
+                    if (resource.options.onRemove) {
+                        resource.options.onRemove(doc, req, async function (err) {
+                            if (err) {
+                                throw err;
+                            }
+                            resolve(removeDoc(doc, resource));
+                        });
+                    }
+                    else {
+                        resolve(removeDoc(doc, resource));
+                    }
                 });
+            }
+            this.processEntity(req, res, async function () {
+                if (!req.resource) {
+                    next();
+                    return;
+                }
+                let doc = req.doc;
+                try {
+                    void await runDeletion(doc, req.resource);
+                    res.status(200).send();
+                }
+                catch (e) {
+                    if (e instanceof ForeignKeyError) {
+                        res.status(400).send(e.message);
+                    }
+                    else {
+                        res.status(500).send(e.message);
+                    }
+                }
             });
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.entityList = function () {
+    entityList() {
         return _.bind(function (req, res, next) {
-            var that = this;
+            const that = this;
             this.processEntity(req, res, function () {
                 if (!req.resource) {
                     return next();
                 }
-                that.getListFields(req.resource, req.doc, function (err, display) {
-                    if (err) {
-                        return res.status(500).send(err);
+                const returnRawParam = req.query?.returnRaw ? !!JSON.parse(req.query.returnRaw) : false;
+                if (returnRawParam) {
+                    const result = { _id: req.doc._id };
+                    for (const field of req.resource.options.listFields) {
+                        result[field.field] = req.doc[field.field];
+                    }
+                    return res.send(result);
+                }
+                else {
+                    that.getListFields(req.resource, req.doc, function (err, display) {
+                        if (err) {
+                            return res.status(500).send(err);
+                        }
+                        else {
+                            return res.send({ list: display });
+                        }
+                    });
+                }
+            });
+        }, this);
+    }
+    ;
+    // To disambiguate the contents of items - assumed to be the results of a single resource lookup or search - 
+    // pass the result of this function as the second argument to the disambiguate() function.
+    // equalityProps should identify the property(s) of the items that must ALL be equal for two items to
+    // be considered ambiguous.
+    // disambiguationResourceName should identify the resource whose list field(s) should be used to generate
+    // the disambiguation text for ambiguous results later.
+    buildSingleResourceAmbiguousRecordStore(items, equalityProps, disambiguationResourceName) {
+        const ambiguousResults = [];
+        for (let i = 0; i < items.length - 1; i++) {
+            for (let j = i + 1; j < items.length; j++) {
+                if (!equalityProps.some((p) => items[i][p] !== items[j][p])) {
+                    if (!ambiguousResults.includes(items[i])) {
+                        ambiguousResults.push(items[i]);
+                    }
+                    if (!ambiguousResults.includes(items[j])) {
+                        ambiguousResults.push(items[j]);
+                    }
+                }
+            }
+        }
+        return { [disambiguationResourceName]: ambiguousResults };
+    }
+    // An alternative to buildSingleResourceAmbiguousRecordStore() for use when disambiguating the results of a
+    // multi-resource lookup or search.  In this case, all items need to include the name of the resource that
+    // will be used (when necessary) to yield their disambiguation text later.  The property of items that holds
+    // that resource name should be identified by the disambiguationResourceNameProp parameter.
+    // The scary-looking templating used here ensures that the items really do all have an (optional) string
+    // property with the name identified by disambiguationResourceNameProp.  For the avoidance of doubt, "prop"
+    // here could be anything - "foo in f" would achieve the same result.
+    buildMultiResourceAmbiguousRecordStore(items, equalityProps, disambiguationResourceNameProp) {
+        const store = {};
+        for (let i = 0; i < items.length - 1; i++) {
+            for (let j = i + 1; j < items.length; j++) {
+                if (items[i][disambiguationResourceNameProp] &&
+                    items[i][disambiguationResourceNameProp] === items[j][disambiguationResourceNameProp] &&
+                    !equalityProps.some((p) => items[i][p] !== items[j][p])) {
+                    if (!store[items[i][disambiguationResourceNameProp]]) {
+                        store[items[i][disambiguationResourceNameProp]] = [];
+                    }
+                    if (!store[items[i][disambiguationResourceNameProp]].includes(items[i])) {
+                        store[items[i][disambiguationResourceNameProp]].push(items[i]);
+                    }
+                    if (!store[items[i][disambiguationResourceNameProp]].includes(items[j])) {
+                        store[items[i][disambiguationResourceNameProp]].push(items[j]);
+                    }
+                }
+            }
+        }
+        return store;
+    }
+    // return just the id and list fields for all of the records from req.resource.
+    // list fields are those whose schema entry has a value for the "list" attribute (except where this is { ref: true })
+    // if the resource has no explicit list fields identified, the first string field will be returned.  if the resource
+    // doesn't have any string fields either, the first (non-id) field will be returned.
+    // usually, we will respond with an array of ILookupItem objects, where the .text property of those objects is the concatenation
+    // of all of the document's list fields (space-seperated).
+    // to request the documents without this transformation applied, include "c=true" in the query string.
+    // the query string can also be used to filter and order the response, by providing values for "f" (find), "l" (limit),
+    // "s" (skip) and/or "o" (order).
+    // results will be disambiguated if req.resource includes disambiguation parameters in its resource options.
+    // where c=true, the disambiguation will be added as a suffix to the .text property of the returned ILookupItem objects.
+    // otherwise, if the resource has just one list field, the disambiguation will be appended to the values of that field, and if
+    // it has multiple list fields, it will be returned as an additional property of the returned (untransformed) objects
+    internalEntityListAll(req, callback) {
+        const projection = this.generateListFieldProjection(req.resource);
+        const listFields = Object.keys(projection);
+        const aggregationParam = req.query.a ? JSON.parse(req.query.a) : null;
+        const findParam = req.query.f ? JSON.parse(req.query.f) : {};
+        const limitParam = req.query.l ? JSON.parse(req.query.l) : 0;
+        const skipParam = req.query.s ? JSON.parse(req.query.s) : 0;
+        const orderParam = req.query.o ? JSON.parse(req.query.o) : req.resource.options.listOrder;
+        const concatenateParam = req.query.c ? JSON.parse(req.query.c) : true;
+        const resOpts = req.resource.options;
+        let disambiguationField;
+        let disambiguationResourceName;
+        if (resOpts?.disambiguation) {
+            disambiguationField = resOpts.disambiguation.field;
+            if (disambiguationField) {
+                projection[disambiguationField] = 1;
+                disambiguationResourceName = resOpts.disambiguation.resource;
+            }
+        }
+        const that = this;
+        this.filteredFind(req.resource, req, aggregationParam, findParam, projection, orderParam, limitParam, skipParam, function (err, docs) {
+            if (err) {
+                return callback(err);
+            }
+            else {
+                docs = docs.map((d) => d.toObject());
+                if (concatenateParam) {
+                    const transformed = docs.map((doc) => {
+                        let text = "";
+                        for (const field of listFields) {
+                            if (doc[field]) {
+                                if (text !== "") {
+                                    text += " ";
+                                }
+                                text += doc[field];
+                            }
+                        }
+                        const disambiguationId = disambiguationField ? doc[disambiguationField] : undefined;
+                        return { id: doc._id, text, disambiguationId };
+                    });
+                    if (disambiguationResourceName) {
+                        that.disambiguate(transformed, that.buildSingleResourceAmbiguousRecordStore(transformed, ["text"], disambiguationResourceName), "disambiguationId", (item, disambiguationText) => {
+                            item.text += ` (${disambiguationText})`;
+                        }, (err) => {
+                            callback(err, transformed);
+                        });
                     }
                     else {
-                        return res.send({ list: display });
+                        return callback(null, transformed);
                     }
-                });
+                }
+                else {
+                    if (disambiguationResourceName) {
+                        that.disambiguate(docs, that.buildSingleResourceAmbiguousRecordStore(docs, listFields, disambiguationResourceName), disambiguationField, (item, disambiguationText) => {
+                            if (listFields.length === 1) {
+                                item[listFields[0]] += ` (${disambiguationText})`;
+                            }
+                            else {
+                                // store the text against hard-coded property name "disambiguation", rather than (say) using 
+                                // item[disambiguationResourceName], because if disambiguationResourceName === disambiguationField,
+                                // that value would end up being deleted again when the this.disambiguate() call (which we have
+                                // been called from) does its final tidy-up and deletes [disambiguationField] from all of the items in docs
+                                item.disambiguation = disambiguationText;
+                            }
+                        }, (err) => {
+                            callback(err, docs);
+                        });
+                    }
+                    else {
+                        return callback(null, docs);
+                    }
+                }
+            }
+        });
+    }
+    ;
+    entityListAll() {
+        return _.bind(function (req, res, next) {
+            if (!(req.resource = this.getResource(req.params.resourceName))) {
+                return next();
+            }
+            this.internalEntityListAll(req, function (err, resultsObject) {
+                if (err) {
+                    res.status(400, err);
+                }
+                else {
+                    res.send(resultsObject);
+                }
             });
         }, this);
-    };
+    }
     ;
-    FormsAngular.prototype.extractTimestampFromMongoID = function (record) {
-        var timestamp = record.toString().substring(0, 8);
+    extractTimestampFromMongoID(record) {
+        let timestamp = record.toString().substring(0, 8);
         return new Date(parseInt(timestamp, 16) * 1000);
-    };
-    return FormsAngular;
-}());
+    }
+}
 exports.FormsAngular = FormsAngular;
-var ForeignKeyError = /** @class */ (function (_super) {
-    __extends(ForeignKeyError, _super);
-    function ForeignKeyError(resourceName, foreignKeyOnResource, foreignItem, id) {
-        var _this = _super.call(this, "Cannot delete this ".concat(resourceName, ", as it is the ").concat(foreignItem, " on ").concat(foreignKeyOnResource, " ").concat(id)) || this;
-        _this.name = "ForeignKeyError";
-        _this.stack = new global.Error('').stack;
-        return _this;
+class ForeignKeyError extends global.Error {
+    constructor(resourceName, foreignKeyOnResource, foreignItem, id) {
+        super(`Cannot delete this ${resourceName}, as it is the ${foreignItem} on ${foreignKeyOnResource} ${id}`);
+        this.name = "ForeignKeyError";
+        this.stack = new global.Error('').stack;
     }
-    return ForeignKeyError;
-}(global.Error));
+}