@nymphjs/nymph 1.0.0-beta.13 → 1.0.0-beta.130

package/dist/driver/NymphDriver.js

@@ -1,34 +1,51 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const lodash_1 = require("lodash");
-const n_readlines_1 = __importDefault(require("n-readlines"));
-const strtotime_1 = __importDefault(require("locutus/php/datetime/strtotime"));
-const guid_1 = require("@nymphjs/guid");
-const errors_1 = require("../errors");
-const utils_1 = require("../utils");
+import fs from 'node:fs';
+import { difference } from 'lodash-es';
+import ReadLines from 'n-readlines';
+import { strtotime } from 'locutus/php/datetime/index';
+import { Tokenizer } from '@sciactive/tokenizer';
+import Entity from '../Entity.js';
+import { ClassNotAvailableError, InvalidParametersError, UnableToConnectError, } from '../errors/index.js';
+import { classNamesToEntityConstructors, entitiesToReferences, entityConstructorsToClassNames, referencesToEntities, xor, } from '../utils.js';
+// from: https://stackoverflow.com/a/6969486/664915
 function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
 }
-class NymphDriver {
-    constructor() {
-        this.nymph = new Proxy({}, {
-            get() {
-                throw new Error('Attempted access of Nymph instance before driver initialization!');
-            },
-        });
-        this.entityCache = {};
-        this.entityCount = {};
-        this.putDataCounter = 0;
-    }
+/**
+ * A Nymph database driver.
+ */
+export default class NymphDriver {
+    nymph = new Proxy({}, {
+        get() {
+            throw new Error('Attempted access of Nymph instance before driver initialization!');
+        },
+    });
+    tokenizer = new Tokenizer();
+    /**
+     * A cache to make entity retrieval faster.
+     */
+    entityCache = {};
+    /**
+     * A counter for the entity cache to determine the most accessed entities.
+     */
+    entityCount = {};
+    /**
+     * Protect against infinite loops.
+     */
+    putDataCounter = 0;
+    /**
+     * Initialize the Nymph driver.
+     *
+     * This is meant to be called internally by Nymph. Don't call this directly.
+     *
+     * @param nymph The Nymph instance.
+     */
     init(nymph) {
         this.nymph = nymph;
     }
     posixRegexMatch(pattern, subject, caseInsensitive = false) {
         const posixClasses = [
+            // '[[:<:]]',
+            // '[[:>:]]',
             '[:alnum:]',
             '[:alpha:]',
             '[:ascii:]',
@@ -45,17 +62,21 @@ class NymphDriver {
             '[:xdigit:]',
         ];
         const jsClasses = [
+            // '\b(?=\w)',
+            // '(?<=\w)\b',
             '[A-Za-z0-9]',
             '[A-Za-z]',
             '[\x00-\x7F]',
-            '[ \t]',
-            '[\x00-\x1F\x7F]',
-            '[0-9]',
-            '[\x21-\x7E]',
+            '[ \t]', // '\s',
+            '[\x00-\x1F\x7F]', // '[\000\001\002\003\004\005\006\007\008\009\010\011\012\013\014'.
+            //   '\015\016\017\018\019\020\021\022\023\024\025\026\027\028\029'.
+            //   '\030\031\032\033\034\035\036\037\177]',
+            '[0-9]', // '\d',
+            '[\x21-\x7E]', // '[A-Za-z0-9!"#$%&\'()*+,\-./:;<=>?@[\\\]^_`{|}\~]',
             '[a-z]',
-            '[\x20-\x7E]',
-            '[!"#$%&\'()*+,-./:;<=>?@[\\\\\\]^_‘{|}~]',
-            '[ \t\r\n\v\f]',
+            '[\x20-\x7E]', // '[A-Za-z0-9!"#$%&\'()*+,\-./:;<=>?@[\\\]^_`{|}\~]',
+            '[!"#$%&\'()*+,-./:;<=>?@[\\\\\\]^_‘{|}~]', // '[!"#$%&\'()*+,\-./:;<=>?@[\\\]^_`{|}\~]',
+            '[ \t\r\n\v\f]', // '[\t\n\x0B\f\r ]',
             '[A-Z]',
             '[A-Za-z0-9_]',
             '[0-9A-Fa-f]',
@@ -67,16 +88,21 @@ class NymphDriver {
         let re = new RegExp(newPattern, caseInsensitive ? 'mi' : 'm');
         return re.test(subject);
     }
+    checkIndexName(name) {
+        if (name.match(/[^a-z0-9_]/)) {
+            throw new Error('Index names can only contain lowercase letters, numbers, and underscores.');
+        }
+    }
     async export(filename) {
         try {
-            const fhandle = fs_1.default.openSync(filename, 'w');
+            const fhandle = fs.openSync(filename, 'w');
             if (!fhandle) {
-                throw new errors_1.InvalidParametersError('Provided filename is not writeable.');
+                throw new InvalidParametersError('Provided filename is not writeable.');
             }
-            await this.exportEntities((line) => {
-                fs_1.default.writeSync(fhandle, `${line}\n`);
-            });
-            fs_1.default.closeSync(fhandle);
+            for await (let entry of this.exportDataIterator()) {
+                fs.writeSync(fhandle, entry.content);
+            }
+            fs.closeSync(fhandle);
         }
         catch (e) {
             return false;
@@ -84,98 +110,159 @@ class NymphDriver {
         return true;
     }
     async exportPrint() {
-        await this.exportEntities((line) => {
-            console.log(line);
-        });
+        for await (let entry of this.exportDataIterator()) {
+            console.log(entry.content);
+        }
         return true;
     }
-    async importFromFile(filename, saveEntityCallback, saveUIDCallback, startTransactionCallback = null, commitTransactionCallback = null) {
-        let rl;
-        try {
-            rl = new n_readlines_1.default(filename);
-        }
-        catch (e) {
-            throw new errors_1.InvalidParametersError('Provided filename is unreadable.');
+    async importDataIterator(lines, options, transaction) {
+        const first = lines[Symbol.iterator]().next();
+        if (first.done || first.value !== '#nex2') {
+            throw new Error('Tried to import a file that is not a NEX v2 file.');
         }
-        let guid = null;
-        let line = false;
-        let sdata = {};
-        let tags = [];
-        let etype = '__undefined';
-        if (startTransactionCallback) {
-            await startTransactionCallback();
+        if (transaction) {
+            await this.internalTransaction('nymph-import');
         }
-        while ((line = rl.next())) {
-            const text = line.toString('utf8');
-            if (text.match(/^\s*#/)) {
-                continue;
-            }
-            const entityMatch = text.match(/^\s*{([0-9A-Fa-f]+)}<([-\w_]+)>\[([^\]]*)\]\s*$/);
-            const propMatch = text.match(/^\s*([^=]+)\s*=\s*(.*\S)\s*$/);
-            const uidMatch = text.match(/^\s*<([^>]+)>\[(\d+)\]\s*$/);
-            if (uidMatch) {
-                await saveUIDCallback(uidMatch[1], Number(uidMatch[2]));
-            }
-            else if (entityMatch) {
-                if (guid) {
-                    await saveEntityCallback(guid, tags, sdata, etype);
-                    guid = null;
-                    tags = [];
-                    sdata = {};
-                    etype = '__undefined';
-                }
-                guid = entityMatch[1];
-                etype = entityMatch[2];
-                tags = entityMatch[3].split(',');
+        try {
+            let guid = null;
+            let sdata = {};
+            let tags = [];
+            let etype = '__undefined';
+            for (let line of lines) {
+                if (line.match(/^\s*#/)) {
+                    continue;
+                }
+                const entityMatch = line.match(/^\s*{([0-9A-Fa-f]+)}<([-\w_]+)>\[([^\]]*)\]\s*$/);
+                const propMatch = line.match(/^\s*([^=]+)\s*=\s*(.*\S)\s*$/);
+                const uidMatch = line.match(/^\s*<([^>]+)>\[(\d+)\]\s*$/);
+                if (uidMatch) {
+                    // Add the UID.
+                    await this.importUID({
+                        name: uidMatch[1],
+                        value: Number(uidMatch[2]),
+                    });
+                }
+                else if (entityMatch) {
+                    // Save the current entity.
+                    if (guid) {
+                        const cdate = Number(JSON.parse(sdata.cdate));
+                        delete sdata.cdate;
+                        const mdate = Number(JSON.parse(sdata.mdate));
+                        delete sdata.mdate;
+                        try {
+                            await this.importEntity({
+                                guid,
+                                cdate,
+                                mdate,
+                                tags,
+                                sdata,
+                                etype,
+                            });
+                        }
+                        catch (e) {
+                            if (!(e instanceof ClassNotAvailableError) ||
+                                !options?.ignoreUnknownETypes) {
+                                throw e;
+                            }
+                        }
+                        guid = null;
+                        tags = [];
+                        sdata = {};
+                        etype = '__undefined';
+                    }
+                    // Record the new entity's info.
+                    guid = entityMatch[1];
+                    etype = entityMatch[2];
+                    tags = entityMatch[3].split(',');
+                }
+                else if (propMatch) {
+                    // Add the variable to the new entity.
+                    if (guid) {
+                        sdata[propMatch[1]] = propMatch[2];
+                    }
+                }
+                // Clear the entity cache.
+                this.entityCache = {};
             }
-            else if (propMatch) {
-                if (guid) {
-                    sdata[propMatch[1]] = propMatch[2];
+            // Save the last entity.
+            if (guid) {
+                const cdate = Number(JSON.parse(sdata.cdate));
+                delete sdata.cdate;
+                const mdate = Number(JSON.parse(sdata.mdate));
+                delete sdata.mdate;
+                try {
+                    await this.importEntity({ guid, cdate, mdate, tags, sdata, etype });
+                }
+                catch (e) {
+                    if (!(e instanceof ClassNotAvailableError) ||
+                        !options?.ignoreUnknownETypes) {
+                        throw e;
+                    }
                 }
             }
-            this.entityCache = {};
-        }
-        if (guid) {
-            await saveEntityCallback(guid, tags, sdata, etype);
+            if (transaction) {
+                await this.commit('nymph-import');
+            }
         }
-        if (commitTransactionCallback) {
-            await commitTransactionCallback();
+        catch (e) {
+            await this.rollback('nymph-import');
+            throw e;
         }
         return true;
     }
-    checkData(data, sdata, selectors, guid = null, tags = null) {
-        const formattedSelectors = this.formatSelectors(selectors).selectors;
-        for (const curSelector of formattedSelectors) {
-            const type = curSelector.type;
-            const typeIsNot = type === '!&' || type === '!|';
-            const typeIsOr = type === '|' || type === '!|';
-            let pass = !typeIsOr;
-            for (const k in curSelector) {
-                const key = k;
-                const value = curSelector[key];
-                if (key === 'type' || value == null) {
-                    continue;
-                }
-                const clauseNot = key.substr(0, 1) === '!';
-                if (key === 'selector' || key === '!selector') {
-                    const tmpArr = (Array.isArray(value) ? value : [value]);
-                    pass = (0, utils_1.xor)(this.checkData(data, sdata, tmpArr, guid, tags), (0, utils_1.xor)(typeIsNot, clauseNot));
+    async importData(text, transaction) {
+        return await this.importDataIterator(text.split('\n'), undefined, transaction);
+    }
+    async import(filename, options, transaction) {
+        let rl;
+        try {
+            rl = new ReadLines(filename);
+        }
+        catch (e) {
+            throw new InvalidParametersError('Provided filename is unreadable.');
+        }
+        const lines = {
+            *[Symbol.iterator]() {
+                let line;
+                while ((line = rl.next())) {
+                    yield line.toString('utf8');
                 }
-                else {
-                    if (key === 'qref' || key === '!qref') {
-                        throw new Error("Can't use checkData on qref clauses.");
+            },
+        };
+        return await this.importDataIterator(lines, options, transaction);
+    }
+    checkData(etype, data, sdata, selectors, guid = null, tags = null) {
+        try {
+            const EntityClass = this.nymph.getEntityClassByEtype(etype);
+            const formattedSelectors = this.formatSelectors(selectors).selectors;
+            for (const curSelector of formattedSelectors) {
+                const type = curSelector.type;
+                const typeIsNot = type === '!&' || type === '!|';
+                const typeIsOr = type === '|' || type === '!|';
+                let pass = !typeIsOr;
+                for (const k in curSelector) {
+                    const key = k;
+                    const value = curSelector[key];
+                    if (key === 'type' || value == null) {
+                        continue;
+                    }
+                    const clauseNot = key.substring(0, 1) === '!';
+                    if (key === 'selector' || key === '!selector') {
+                        const tmpArr = (Array.isArray(value) ? value : [value]);
+                        pass = xor(this.checkData(etype, data, sdata, tmpArr, guid, tags), xor(typeIsNot, clauseNot));
                     }
                     else {
-                        for (const curValue of value) {
-                            if (curValue == null) {
-                                continue;
-                            }
-                            if (((key === 'guid' || key === '!guid') && guid == null) ||
-                                ((key === 'tag' || key === '!tag') && tags == null)) {
-                                pass = true;
-                            }
-                            else {
+                        if (key === 'qref' || key === '!qref') {
+                            throw new Error("Can't use checkData on qref clauses.");
+                        }
+                        else {
+                            // Check if it doesn't pass any for &, check if it passes any for |.
+                            for (const curValue of value) {
+                                if (curValue == null) {
+                                    continue;
+                                }
                                 const propName = curValue[0];
+                                // Unserialize the data for this variable.
                                 if (propName in sdata) {
                                     data[propName] = JSON.parse(sdata[propName]);
                                     delete sdata[propName];
@@ -183,99 +270,130 @@ class NymphDriver {
                                 switch (key) {
                                     case 'guid':
                                     case '!guid':
-                                        pass = (0, utils_1.xor)(guid == propName, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(guid == propName, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'tag':
                                     case '!tag':
-                                        pass = (0, utils_1.xor)((tags ?? []).indexOf(propName) !== -1, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor((tags ?? []).indexOf(propName) !== -1, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'defined':
                                     case '!defined':
-                                        pass = (0, utils_1.xor)(propName in data, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'truthy':
                                     case '!truthy':
-                                        pass = (0, utils_1.xor)(propName in data && data[propName], (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data && data[propName], xor(typeIsNot, clauseNot));
                                         break;
                                     case 'ref':
                                     case '!ref':
                                         const testRefValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data &&
-                                            this.entityReferenceSearch(data[propName], testRefValue), (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data &&
+                                            this.entityReferenceSearch(data[propName], testRefValue), xor(typeIsNot, clauseNot));
                                         break;
                                     case 'equal':
                                     case '!equal':
                                         const testEqualValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data &&
+                                        pass = xor(propName in data &&
                                             JSON.stringify(data[propName]) ===
-                                                JSON.stringify(testEqualValue), (0, utils_1.xor)(typeIsNot, clauseNot));
+                                                JSON.stringify(testEqualValue), xor(typeIsNot, clauseNot));
                                         break;
                                     case 'contain':
                                     case '!contain':
                                         const testContainValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data &&
-                                            JSON.stringify(data[propName]).indexOf(JSON.stringify(testContainValue)) !== -1, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data &&
+                                            JSON.stringify(data[propName]).indexOf(JSON.stringify(testContainValue)) !== -1, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'like':
                                     case '!like':
                                         const testLikeValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data &&
+                                        pass = xor(propName in data &&
                                             new RegExp('^' +
                                                 escapeRegExp(testLikeValue)
                                                     .replace('%', () => '.*')
                                                     .replace('_', () => '.') +
-                                                '$').test(data[propName]), (0, utils_1.xor)(typeIsNot, clauseNot));
+                                                '$').test(data[propName]), xor(typeIsNot, clauseNot));
+                                        break;
+                                    case 'ilike':
+                                    case '!ilike':
+                                        const testILikeValue = curValue[1];
+                                        pass = xor(propName in data &&
+                                            new RegExp('^' +
+                                                escapeRegExp(testILikeValue)
+                                                    .replace('%', () => '.*')
+                                                    .replace('_', () => '.') +
+                                                '$', 'i').test(data[propName]), xor(typeIsNot, clauseNot));
                                         break;
                                     case 'match':
                                     case '!match':
                                         const testMatchValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data &&
-                                            this.posixRegexMatch(testMatchValue, data[propName]), (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        // Convert a POSIX regex to a JS regex.
+                                        pass = xor(propName in data &&
+                                            this.posixRegexMatch(testMatchValue, data[propName]), xor(typeIsNot, clauseNot));
                                         break;
                                     case 'imatch':
                                     case '!imatch':
                                         const testIMatchValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data &&
-                                            this.posixRegexMatch(testIMatchValue, data[propName], true), (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        // Convert a POSIX regex to a JS regex.
+                                        pass = xor(propName in data &&
+                                            this.posixRegexMatch(testIMatchValue, data[propName], true), xor(typeIsNot, clauseNot));
+                                        break;
+                                    case 'search':
+                                    case '!search':
+                                        const testSearchValue = curValue[1];
+                                        const tokenString = propName in data
+                                            ? (EntityClass.getFTSText(propName, data[propName]) ??
+                                                '')
+                                            : '';
+                                        pass = xor(propName in data &&
+                                            this.tokenizer.searchString(testSearchValue, tokenString), xor(typeIsNot, clauseNot));
                                         break;
                                     case 'gt':
                                     case '!gt':
                                         const testGTValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data && data[propName] > testGTValue, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data && data[propName] > testGTValue, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'gte':
                                     case '!gte':
                                         const testGTEValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data && data[propName] >= testGTEValue, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data && data[propName] >= testGTEValue, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'lt':
                                     case '!lt':
                                         const testLTValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data && data[propName] < testLTValue, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data && data[propName] < testLTValue, xor(typeIsNot, clauseNot));
                                         break;
                                     case 'lte':
                                     case '!lte':
                                         const testLTEValue = curValue[1];
-                                        pass = (0, utils_1.xor)(propName in data && data[propName] <= testLTEValue, (0, utils_1.xor)(typeIsNot, clauseNot));
+                                        pass = xor(propName in data && data[propName] <= testLTEValue, xor(typeIsNot, clauseNot));
                                         break;
                                 }
-                            }
-                            if (!(0, utils_1.xor)(typeIsOr, pass)) {
-                                break;
+                                if (!xor(typeIsOr, pass)) {
+                                    break;
+                                }
                             }
                         }
                     }
+                    if (!xor(typeIsOr, pass)) {
+                        break;
+                    }
                 }
-                if (!(0, utils_1.xor)(typeIsOr, pass)) {
-                    break;
+                if (!pass) {
+                    return false;
                 }
             }
-            if (!pass) {
-                return false;
-            }
+            return true;
+        }
+        catch (e) {
+            this.nymph.config.debugError('nymph', `Failed to check entity data: ${e}`);
+            throw e;
         }
-        return true;
     }
+    /**
+     * Remove all copies of an entity from the cache.
+     *
+     * @param guid The GUID of the entity to remove.
+     */
     cleanCache(guid) {
         delete this.entityCache[guid];
     }
@@ -292,7 +410,15 @@ class NymphDriver {
         }
         return ret;
     }
+    /**
+     * Search through a value for an entity reference.
+     *
+     * @param value Any value to search.
+     * @param entity An entity, GUID, or array of either to search for.
+     * @returns True if the reference is found, false otherwise.
+     */
     entityReferenceSearch(value, entity) {
+        // Get the GUID, if the passed $entity is an object.
         const guids = [];
         if (Array.isArray(entity)) {
             if (entity[0] === 'nymph_entity_reference') {
@@ -323,7 +449,15 @@ class NymphDriver {
             guids.indexOf(value[1]) !== -1) {
             return true;
         }
-        if (Array.isArray(value) || typeof value === 'object') {
+        if (value instanceof Entity &&
+            value.guid != null &&
+            guids.indexOf(value.guid) !== -1) {
+            return true;
+        }
+        // Search through arrays and objects looking for the reference.
+        if (value != null &&
+            (Array.isArray(value) ||
+                (typeof value === 'object' && !(value instanceof Entity)))) {
             for (const key in value) {
                 if (this.entityReferenceSearch(value[key], guids)) {
                     return true;
@@ -332,6 +466,177 @@ class NymphDriver {
         }
         return false;
     }
+    removeAndReturnACValues(etype, data, sdata) {
+        let user = null;
+        let group = null;
+        let acUser = null;
+        let acGroup = null;
+        let acOther = null;
+        let acRead = null;
+        let acWrite = null;
+        let acFull = null;
+        if (this.nymph.tilmeld != null) {
+            // Since Tilmeld is installed, we need to fill the AC vars.
+            const userValue = 'user' in sdata
+                ? JSON.parse(sdata.user)
+                : 'user' in data
+                    ? data.user
+                    : null;
+            if (Array.isArray(userValue) &&
+                userValue[0] === 'nymph_entity_reference' &&
+                userValue[2] === 'User' &&
+                typeof userValue[1] === 'string' &&
+                userValue[1].match(/^[0-9a-f]{24}$/i)) {
+                user = userValue[1];
+            }
+            const groupValue = 'group' in sdata
+                ? JSON.parse(sdata.group)
+                : 'group' in data
+                    ? data.group
+                    : null;
+            if (Array.isArray(groupValue) &&
+                groupValue[0] === 'nymph_entity_reference' &&
+                groupValue[2] === 'Group' &&
+                typeof groupValue[1] === 'string' &&
+                groupValue[1].match(/^[0-9a-f]{24}$/i)) {
+                group = groupValue[1];
+            }
+            if (etype !== 'tilmeld_user' && etype !== 'tilmeld_group') {
+                const acUserValue = 'acUser' in sdata
+                    ? JSON.parse(sdata.acUser)
+                    : 'acUser' in data
+                        ? data.acUser
+                        : null;
+                if (typeof acUserValue === 'number' &&
+                    !isNaN(acUserValue) &&
+                    acUserValue >= 0) {
+                    acUser = acUserValue;
+                }
+                const acGroupValue = 'acGroup' in sdata
+                    ? JSON.parse(sdata.acGroup)
+                    : 'acGroup' in data
+                        ? data.acGroup
+                        : null;
+                if (typeof acGroupValue === 'number' &&
+                    !isNaN(acGroupValue) &&
+                    acGroupValue >= 0) {
+                    acGroup = acGroupValue;
+                }
+                const acOtherValue = 'acOther' in sdata
+                    ? JSON.parse(sdata.acOther)
+                    : 'acOther' in data
+                        ? data.acOther
+                        : null;
+                if (typeof acOtherValue === 'number' &&
+                    !isNaN(acOtherValue) &&
+                    acOtherValue >= 0) {
+                    acOther = acOtherValue;
+                }
+                const acReadValue = 'acRead' in sdata
+                    ? JSON.parse(sdata.acRead)
+                    : 'acRead' in data
+                        ? data.acRead
+                        : null;
+                if (Array.isArray(acReadValue)) {
+                    const acReadArray = [];
+                    for (let acReadEntry of acReadValue) {
+                        if (typeof acReadEntry === 'string' &&
+                            acReadEntry.match(/^[0-9a-f]{24}$/i)) {
+                            acReadArray.push(acReadEntry);
+                        }
+                        else if (Array.isArray(acReadEntry) &&
+                            acReadEntry[0] === 'nymph_entity_reference' &&
+                            (acReadEntry[2] === 'User' || acReadEntry[2] === 'Group') &&
+                            typeof acReadEntry[1] === 'string' &&
+                            acReadEntry[1].match(/^[0-9a-f]{24}$/i)) {
+                            acReadArray.push(acReadEntry[1]);
+                        }
+                    }
+                    if (acReadArray.length) {
+                        acRead = acReadArray;
+                    }
+                }
+                const acWriteValue = 'acWrite' in sdata
+                    ? JSON.parse(sdata.acWrite)
+                    : 'acWrite' in data
+                        ? data.acWrite
+                        : null;
+                if (Array.isArray(acWriteValue)) {
+                    const acWriteArray = [];
+                    for (let acWriteEntry of acWriteValue) {
+                        if (typeof acWriteEntry === 'string' &&
+                            acWriteEntry.match(/^[0-9a-f]{24}$/i)) {
+                            acWriteArray.push(acWriteEntry);
+                        }
+                        else if (Array.isArray(acWriteEntry) &&
+                            acWriteEntry[0] === 'nymph_entity_reference' &&
+                            (acWriteEntry[2] === 'User' || acWriteEntry[2] === 'Group') &&
+                            typeof acWriteEntry[1] === 'string' &&
+                            acWriteEntry[1].match(/^[0-9a-f]{24}$/i)) {
+                            acWriteArray.push(acWriteEntry[1]);
+                        }
+                    }
+                    if (acWriteArray.length) {
+                        acWrite = acWriteArray;
+                    }
+                }
+                const acFullValue = 'acFull' in sdata
+                    ? JSON.parse(sdata.acFull)
+                    : 'acFull' in data
+                        ? data.acFull
+                        : null;
+                if (Array.isArray(acFullValue)) {
+                    const acFullArray = [];
+                    for (let acFullEntry of acFullValue) {
+                        if (typeof acFullEntry === 'string' &&
+                            acFullEntry.match(/^[0-9a-f]{24}$/i)) {
+                            acFullArray.push(acFullEntry);
+                        }
+                        else if (Array.isArray(acFullEntry) &&
+                            acFullEntry[0] === 'nymph_entity_reference' &&
+                            (acFullEntry[2] === 'User' || acFullEntry[2] === 'Group') &&
+                            typeof acFullEntry[1] === 'string' &&
+                            acFullEntry[1].match(/^[0-9a-f]{24}$/i)) {
+                            acFullArray.push(acFullEntry[1]);
+                        }
+                    }
+                    if (acFullArray.length) {
+                        acFull = acFullArray;
+                    }
+                }
+            }
+            // Delete all of the data, so it doesn't go into the database as rows in
+            // the data tables.
+            delete sdata.user;
+            delete data.user;
+            delete sdata.group;
+            delete data.group;
+            delete sdata.acUser;
+            delete data.acUser;
+            delete sdata.acGroup;
+            delete data.acGroup;
+            delete sdata.acOther;
+            delete data.acOther;
+            delete sdata.acRead;
+            delete data.acRead;
+            delete sdata.acWrite;
+            delete data.acWrite;
+            delete sdata.acFull;
+            delete data.acFull;
+        }
+        return {
+            data,
+            sdata,
+            user,
+            group,
+            acUser,
+            acGroup,
+            acOther,
+            acRead,
+            acWrite,
+            acFull,
+        };
+    }
     formatSelectors(selectors, options = {}) {
         const newSelectors = [];
         const qrefs = [];
@@ -356,9 +661,9 @@ class NymphDriver {
                     for (let i = 0; i < tmpArr.length; i++) {
                         const name = tmpArr[i][0];
                         const [qrefOptions, ...qrefSelectors] = tmpArr[i][1];
-                        const QrefEntityClass = typeof qrefOptions.class === 'string'
+                        const QrefEntityClass = qrefOptions.class
                             ? this.nymph.getEntityClass(qrefOptions.class)
-                            : qrefOptions.class ?? this.nymph.getEntityClass('Entity');
+                            : this.nymph.getEntityClass('Entity');
                         const newOptions = {
                             ...qrefOptions,
                             class: QrefEntityClass,
@@ -377,24 +682,28 @@ class NymphDriver {
                     qrefs.push(...newSelectors.qrefs);
                 }
                 else if (!Array.isArray(value)) {
+                    // @ts-ignore: ts doesn't know what value is here.
                     newSelector[key] = [[value]];
                 }
                 else if (!Array.isArray(value[0])) {
                     if (value.length === 3 &&
                         value[1] == null &&
                         typeof value[2] === 'string') {
-                        newSelector[key] = [[value[0], (0, strtotime_1.default)(value[2]) * 1000]];
+                        // @ts-ignore: ts doesn't know what value is here.
+                        newSelector[key] = [[value[0], strtotime(value[2]) * 1000]];
                     }
                     else {
+                        // @ts-ignore: ts doesn't know what value is here.
                         newSelector[key] = [value];
                     }
                 }
                 else {
+                    // @ts-ignore: ts doesn't know what value is here.
                     newSelector[key] = value.map((curValue) => {
                         if (curValue.length === 3 &&
                             curValue[1] == null &&
                             typeof curValue[2] === 'string') {
-                            return [curValue[0], (0, strtotime_1.default)(curValue[2]) * 1000];
+                            return [curValue[0], (strtotime(curValue[2]) || 0) * 1000];
                         }
                         return curValue;
                     });
@@ -416,7 +725,7 @@ class NymphDriver {
                 if (key === 'type') {
                     continue;
                 }
-                let curQuery = callback(key, value, typeIsOr, typeIsNot);
+                let curQuery = callback({ key, value, typeIsOr, typeIsNot });
                 if (curQuery) {
                     if (curSelectorQuery) {
                         curSelectorQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -430,73 +739,116 @@ class NymphDriver {
         }
         return queryParts;
     }
-    getEntitySync(options = {}, ...selectors) {
-        if (typeof selectors[0] === 'string') {
-            selectors = [{ type: '&', guid: selectors[0] }];
-        }
-        options.limit = 1;
-        const entities = this.getEntitiesSync(options, ...selectors);
-        if (options.return === 'count') {
-            return entities;
-        }
-        if (!entities || !entities.length) {
-            return null;
-        }
-        return entities[0];
-    }
-    getEntitesRowLike(options, selectors, performQueryCallback, rowFetchCallback, freeResultCallback, getCountCallback, getGUIDCallback, getTagsAndDatesCallback, getDataNameAndSValueCallback) {
+    getEntitiesRowLike(options, selectors, performQueryCallback, rowFetchCallback, freeResultCallback, getCountCallback, getGUIDCallback, getTagsAndDatesCallback, getDataNameAndSValueCallback) {
         if (!this.isConnected()) {
-            throw new errors_1.UnableToConnectError('not connected to DB');
+            throw new UnableToConnectError('not connected to DB');
         }
         for (const selector of selectors) {
             if (!selector ||
                 Object.keys(selector).length === 1 ||
                 !('type' in selector) ||
                 ['&', '!&', '|', '!|'].indexOf(selector.type) === -1) {
-                throw new errors_1.InvalidParametersError('Invalid query selector passed: ' + JSON.stringify(selector));
+                throw new InvalidParametersError('Invalid query selector passed: ' + JSON.stringify(selector));
             }
         }
         let entities = [];
         let count = 0;
         const EntityClass = options.class ?? this.nymph.getEntityClass('Entity');
         const etype = EntityClass.ETYPE;
+        if (options.source === 'client' && options.return === 'object') {
+            throw new InvalidParametersError('Object return type not allowed from client.');
+        }
+        // Check if the requested entity is cached.
         if (this.nymph.config.cache &&
             !options.skipCache &&
+            selectors.length &&
             'guid' in selectors[0] &&
             typeof selectors[0].guid === 'number') {
+            // Only safe to use the cache option with no other selectors than a GUID
+            // and tags.
             if (selectors.length === 1 &&
                 selectors[0].type === '&' &&
                 (Object.keys(selectors[0]).length === 2 ||
                     (Object.keys(selectors[0]).length === 3 && 'tag' in selectors[0]))) {
-                const entity = this.pullCache(selectors[0]['guid'], EntityClass.class, !!options.skipAc);
-                if (entity != null &&
-                    entity.guid != null &&
+                const cacheEntity = this.pullCache(selectors[0]['guid']);
+                if (cacheEntity != null &&
+                    cacheEntity.guid != null &&
                     (!('tag' in selectors[0]) ||
-                        entity.hasTag(...(Array.isArray(selectors[0].tag)
+                        !(Array.isArray(selectors[0].tag)
                             ? selectors[0].tag
-                            : [selectors[0].tag])))) {
-                    const guid = entity.guid;
-                    return {
-                        result: Promise.resolve(null),
-                        process: () => options.return === 'count'
-                            ? guid
-                                ? 1
-                                : 0
-                            : options.return === 'guid'
-                                ? [guid]
-                                : [entity],
-                    };
+                            : [selectors[0].tag]).find((tag) => tag == null || !cacheEntity.tags.includes(tag)))) {
+                    // Return the value from the cache.
+                    const { guid, cdate, mdate, tags, data, sdata } = cacheEntity;
+                    if (options.return === 'count') {
+                        return {
+                            result: Promise.resolve(null),
+                            process: () => 1,
+                        };
+                    }
+                    else if (options.return === 'guid') {
+                        return {
+                            result: Promise.resolve(null),
+                            process: () => [guid],
+                        };
+                    }
+                    else if (options.return === 'object') {
+                        return {
+                            result: Promise.resolve(null),
+                            process: () => [
+                                {
+                                    guid,
+                                    cdate,
+                                    mdate,
+                                    tags,
+                                    ...data,
+                                    ...Object.fromEntries(Object.entries(sdata).map(([name, value]) => [
+                                        name,
+                                        JSON.parse(value),
+                                    ])),
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        const entity = this.nymph
+                            .getEntityClass(EntityClass.class)
+                            .factorySync();
+                        if (entity) {
+                            entity.$nymph = this.nymph;
+                            if (options.skipAc != null) {
+                                entity.$useSkipAc(!!options.skipAc);
+                            }
+                            entity.guid = guid;
+                            entity.cdate = cdate;
+                            entity.mdate = mdate;
+                            entity.tags = tags;
+                            entity.$putData(classNamesToEntityConstructors(this.nymph, referencesToEntities(data, this.nymph, !!options.skipAc, false), false), sdata, 'server');
+                            return {
+                                result: Promise.resolve(null),
+                                process: () => [entity],
+                            };
+                        }
+                        return {
+                            result: Promise.resolve(null),
+                            process: () => [],
+                        };
+                    }
                 }
             }
         }
         try {
             const formattedSelectors = this.formatSelectors(selectors, options);
             this.nymph.runQueryCallbacks(options, formattedSelectors.selectors);
-            for (let qref of formattedSelectors.qrefs) {
-                const [options, ...selectors] = qref;
+            for (let i = 0; i < formattedSelectors.qrefs.length; i++) {
+                const [options, ...selectors] = formattedSelectors.qrefs[i];
                 this.nymph.runQueryCallbacks(options, selectors);
+                formattedSelectors.qrefs[i] = [options, ...selectors];
             }
-            const { result } = performQueryCallback(options, formattedSelectors.selectors, etype);
+            const { result } = performQueryCallback({
+                options,
+                selectors: formattedSelectors.selectors,
+                etype,
+            });
             return {
                 result,
                 process: () => {
@@ -521,9 +873,13 @@ class NymphDriver {
                             const cdate = tagsAndDates.cdate;
                             const mdate = tagsAndDates.mdate;
                             let dataNameAndSValue = getDataNameAndSValueCallback(row);
+                            // Data.
                             const data = {};
+                            // Serialized data.
                             const sdata = {};
                             if (dataNameAndSValue.name !== '') {
+                                // This do will keep going and adding the data until the
+                                // next entity is reached. $row will end on the next entity.
                                 do {
                                     dataNameAndSValue = getDataNameAndSValueCallback(row);
                                     sdata[dataNameAndSValue.name] = dataNameAndSValue.svalue;
@@ -531,27 +887,85 @@ class NymphDriver {
                                 } while (row != null && getGUIDCallback(row) === guid);
                             }
                             else {
+                                // Make sure that $row is incremented :)
                                 row = rowFetchCallback();
                             }
-                            const entity = EntityClass.factorySync();
-                            entity.$nymph = this.nymph;
-                            if (options.skipAc != null) {
-                                entity.$useSkipAc(!!options.skipAc);
+                            if (this.nymph.tilmeld) {
+                                if ('user' in tagsAndDates && tagsAndDates.user != null) {
+                                    data.user = [
+                                        'nymph_entity_reference',
+                                        tagsAndDates.user,
+                                        'User',
+                                    ];
+                                    delete sdata.user;
+                                }
+                                if ('group' in tagsAndDates && tagsAndDates.group != null) {
+                                    data.group = [
+                                        'nymph_entity_reference',
+                                        tagsAndDates.group,
+                                        'Group',
+                                    ];
+                                    delete sdata.group;
+                                }
+                                if ('acUser' in tagsAndDates && tagsAndDates.acUser != null) {
+                                    data.acUser = tagsAndDates.acUser;
+                                    delete sdata.acUser;
+                                }
+                                if ('acGroup' in tagsAndDates && tagsAndDates.acGroup != null) {
+                                    data.acGroup = tagsAndDates.acGroup;
+                                    delete sdata.acGroup;
+                                }
+                                if ('acOther' in tagsAndDates && tagsAndDates.acOther != null) {
+                                    data.acOther = tagsAndDates.acOther;
+                                    delete sdata.acOther;
+                                }
+                                if ('acRead' in tagsAndDates && tagsAndDates.acRead != null) {
+                                    data.acRead = tagsAndDates.acRead;
+                                    delete sdata.acRead;
+                                }
+                                if ('acWrite' in tagsAndDates && tagsAndDates.acWrite != null) {
+                                    data.acWrite = tagsAndDates.acWrite;
+                                    delete sdata.acWrite;
+                                }
+                                if ('acFull' in tagsAndDates && tagsAndDates.acFull != null) {
+                                    data.acFull = tagsAndDates.acFull;
+                                    delete sdata.acFull;
+                                }
                             }
-                            entity.guid = guid;
-                            entity.cdate = cdate;
-                            entity.mdate = mdate;
-                            entity.tags = tags;
-                            this.putDataCounter++;
-                            if (this.putDataCounter == 100) {
-                                throw new Error('Infinite loop detected in Entity loading.');
+                            if (options.return === 'object') {
+                                entities.push({
+                                    guid,
+                                    cdate,
+                                    mdate,
+                                    tags,
+                                    ...classNamesToEntityConstructors(this.nymph, referencesToEntities(data, this.nymph, !!options.skipAc, false), false),
+                                    ...Object.fromEntries(Object.entries(sdata).map(([name, value]) => [
+                                        name,
+                                        classNamesToEntityConstructors(this.nymph, referencesToEntities(JSON.parse(value), this.nymph, !!options.skipAc, false), false),
+                                    ])),
+                                });
+                            }
+                            else {
+                                const entity = EntityClass.factorySync();
+                                entity.$nymph = this.nymph;
+                                if (options.skipAc != null) {
+                                    entity.$useSkipAc(!!options.skipAc);
+                                }
+                                entity.guid = guid;
+                                entity.cdate = cdate;
+                                entity.mdate = mdate;
+                                entity.tags = tags;
+                                this.putDataCounter++;
+                                if (this.putDataCounter == 100) {
+                                    throw new Error('Infinite loop detected in Entity loading.');
+                                }
+                                entity.$putData(classNamesToEntityConstructors(this.nymph, referencesToEntities(data, this.nymph, !!options.skipAc, false), false), sdata, 'server');
+                                this.putDataCounter--;
+                                entities.push(entity);
                             }
-                            entity.$putData(data, sdata);
-                            this.putDataCounter--;
                             if (this.nymph.config.cache) {
                                 this.pushCache(guid, cdate, mdate, tags, data, sdata);
                             }
-                            entities.push(entity);
                         }
                     }
                     freeResultCallback();
@@ -569,89 +983,171 @@ class NymphDriver {
         }
     }
     async saveEntityRowLike(entity, saveNewEntityCallback, saveExistingEntityCallback, startTransactionCallback = null, commitTransactionCallback = null) {
-        const mdate = Date.now();
-        const tags = (0, lodash_1.difference)(entity.tags, ['']);
-        const data = entity.$getData();
+        const originalGuid = entity.guid;
+        const originalCdate = entity.cdate;
+        const originalMdate = entity.mdate;
+        // Get a modified date.
+        let mdate = Date.now();
+        if (entity.mdate != null) {
+            if (this.nymph.config.updateMDate === false) {
+                mdate = entity.mdate;
+            }
+            else if (typeof this.nymph.config.updateMDate === 'number') {
+                mdate = entity.mdate + this.nymph.config.updateMDate;
+            }
+            else if (entity.mdate >= mdate) {
+                // If we're saving too fast (within 1 millisecond), increment mdate to
+                // make sure it doesn't conflict in the DB.
+                mdate = entity.mdate + 1;
+            }
+        }
+        const tags = difference(entity.tags, ['']);
+        const data = entityConstructorsToClassNames(
+        // Explicitly save references to entities that aren't saved yet to help
+        // save circular references by saving with a guaranteed GUID.
+        entitiesToReferences(entity.$getData(), false));
         const sdata = entity.$getSData();
+        const uniques = await entity.$getUniques();
         const EntityClass = entity.constructor;
         const etype = EntityClass.ETYPE;
         if (startTransactionCallback) {
             await startTransactionCallback();
         }
         let success = false;
-        if (entity.guid == null) {
-            const cdate = mdate;
-            const newId = (0, guid_1.guid)();
-            success = await saveNewEntityCallback(entity, newId, tags, data, sdata, cdate, etype);
-            if (success) {
-                entity.guid = newId;
-                entity.cdate = cdate;
-                entity.mdate = mdate;
+        try {
+            if (entity.guid == null) {
+                const cdate = mdate;
+                const newId = entity.$getGuaranteedGUID();
+                success = await saveNewEntityCallback({
+                    entity,
+                    guid: newId,
+                    tags,
+                    data,
+                    sdata,
+                    uniques,
+                    cdate,
+                    etype,
+                });
+                if (success) {
+                    entity.guid = newId;
+                    entity.cdate = cdate;
+                    entity.mdate = mdate;
+                }
             }
-        }
-        else {
-            if (this.nymph.config.cache) {
-                this.cleanCache(entity.guid);
+            else {
+                // Removed any cached versions of this entity.
+                if (this.nymph.config.cache) {
+                    this.cleanCache(entity.guid);
+                }
+                success = await saveExistingEntityCallback({
+                    entity,
+                    guid: entity.guid,
+                    tags,
+                    data,
+                    sdata,
+                    uniques,
+                    mdate,
+                    etype,
+                });
+                if (success) {
+                    entity.mdate = mdate;
+                }
             }
-            success = await saveExistingEntityCallback(entity, entity.guid, tags, data, sdata, mdate, etype);
-            if (success) {
-                entity.mdate = mdate;
+            if (commitTransactionCallback) {
+                success = await commitTransactionCallback(success);
             }
+            // Cache the entity.
+            if (success && this.nymph.config.cache) {
+                this.pushCache(entity.guid, entity.cdate, entity.mdate, entity.tags, data, sdata);
+            }
+            if (!success) {
+                entity.guid = originalGuid;
+                entity.cdate = originalCdate;
+                entity.mdate = originalMdate;
+            }
+            return success;
         }
-        if (commitTransactionCallback) {
-            success = await commitTransactionCallback(success);
-        }
-        if (success && this.nymph.config.cache) {
-            this.pushCache(entity.guid, entity.cdate, entity.mdate, entity.tags, data, sdata);
+        catch (e) {
+            if (commitTransactionCallback) {
+                try {
+                    await commitTransactionCallback(false);
+                }
+                catch (e) {
+                    this.nymph.config.debugError('nymph', `Rollback of entity save transaction failed, reason: ${e.message}`);
+                }
+            }
+            entity.guid = originalGuid;
+            entity.cdate = originalCdate;
+            entity.mdate = originalMdate;
+            throw e;
         }
-        return success;
     }
-    pullCache(guid, className, useSkipAc = false) {
+    /**
+     * Pull an entity from the cache.
+     *
+     * @param guid The entity's GUID.
+     * @returns The entity's data or null if it's not cached.
+     */
+    pullCache(guid) {
+        // Increment the entity access count.
         if (!(guid in this.entityCount)) {
             this.entityCount[guid] = 0;
         }
         this.entityCount[guid]++;
         if (guid in this.entityCache) {
-            const entity = this.nymph.getEntityClass(className).factorySync();
-            if (entity) {
-                entity.$nymph = this.nymph;
-                entity.$useSkipAc(!!useSkipAc);
-                entity.guid = guid;
-                entity.cdate = this.entityCache[guid]['cdate'];
-                entity.mdate = this.entityCache[guid]['mdate'];
-                entity.tags = this.entityCache[guid]['tags'];
-                entity.$putData(this.entityCache[guid]['data'], this.entityCache[guid]['sdata']);
-                return entity;
-            }
+            return {
+                guid,
+                cdate: this.entityCache[guid]['cdate'],
+                mdate: this.entityCache[guid]['mdate'],
+                tags: this.entityCache[guid]['tags'],
+                data: this.entityCache[guid]['data'],
+                sdata: this.entityCache[guid]['sdata'],
+            };
         }
         return null;
     }
+    /**
+     * Push an entity onto the cache.
+     *
+     * @param guid The entity's GUID.
+     * @param cdate The entity's cdate.
+     * @param mdate The entity's mdate.
+     * @param tags The entity's tags.
+     * @param data The entity's data.
+     * @param sdata The entity's sdata.
+     */
     pushCache(guid, cdate, mdate, tags, data, sdata) {
         if (guid == null) {
             return;
         }
+        // Increment the entity access count.
         if (!(guid in this.entityCount)) {
             this.entityCount[guid] = 0;
         }
         this.entityCount[guid]++;
+        // Check the threshold.
         if (this.entityCount[guid] < this.nymph.config.cacheThreshold) {
             return;
         }
+        // Cache the entity.
         this.entityCache[guid] = {
-            cdate: cdate,
-            mdate: mdate,
-            tags: tags,
-            data: data,
-            sdata: sdata,
+            cdate,
+            mdate,
+            tags,
+            data,
+            sdata,
         };
         while (this.nymph.config.cacheLimit &&
             Object.keys(this.entityCache).length >= this.nymph.config.cacheLimit) {
+            // Find which entity has been accessed the least.
             const least = Object.entries(this.entityCount)
-                .sort(([guidA, countA], [guidB, countB]) => countA - countB)
+                .sort(([_guidA, countA], [_guidB, countB]) => countA - countB)
                 .pop()?.[0] ?? null;
             if (least == null) {
+                // This should never happen.
                 return;
             }
+            // Remove it.
             delete this.entityCache[least];
             delete this.entityCount[least];
         }
@@ -665,5 +1161,4 @@ class NymphDriver {
         return matches.map((match) => match.replace(re, '$1'));
     }
 }
-exports.default = NymphDriver;
 //# sourceMappingURL=NymphDriver.js.map