@nymphjs/driver-sqlite3 1.0.0-beta.5 → 1.0.0-beta.50

package/dist/SQLite3Driver.js

@@ -7,6 +7,13 @@ const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const nymph_1 = require("@nymphjs/nymph");
 const guid_1 = require("@nymphjs/guid");
 const conf_1 = require("./conf");
+class InternalStore {
+    constructor(link) {
+        this.connected = false;
+        this.transactionsStarted = 0;
+        this.link = link;
+    }
+}
 class SQLite3Driver extends nymph_1.NymphDriver {
     static escape(input) {
         if (input.indexOf('\x00') !== -1) {
@@ -14,63 +21,126 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         }
         return '"' + input.replace(/"/g, () => '""') + '"';
     }
-    constructor(config) {
+    constructor(config, store) {
         super();
-        this.connected = false;
-        this.transactionsStarted = 0;
         this.config = { ...conf_1.SQLite3DriverConfigDefaults, ...config };
+        if (this.config.filename === ':memory:') {
+            this.config.explicitWrite = true;
+        }
         this.prefix = this.config.prefix;
-        this.connect();
+        if (store) {
+            this.store = store;
+        }
+        else {
+            this.connect();
+        }
     }
-    async connect() {
-        const { filename, fileMustExist, timeout, readonly, verbose } = this.config;
-        if (!this.connected) {
+    clone() {
+        return new SQLite3Driver(this.config, this.store);
+    }
+    connect() {
+        if (this.store && this.store.connected) {
+            return Promise.resolve(true);
+        }
+        this._connect(false);
+        return Promise.resolve(this.store.connected);
+    }
+    _connect(write) {
+        const { filename, fileMustExist, timeout, explicitWrite, wal, verbose } = this.config;
+        try {
+            const setOptions = (link) => {
+                if (wal) {
+                    link.pragma('journal_mode = WAL;');
+                }
+                link.pragma('encoding = "UTF-8";');
+                link.pragma('foreign_keys = 1;');
+                link.pragma('case_sensitive_like = 1;');
+                link.function('regexp', { deterministic: true }, ((pattern, subject) => (this.posixRegexMatch(pattern, subject) ? 1 : 0)));
+            };
+            let link;
             try {
-                this.link = new better_sqlite3_1.default(filename, {
-                    readonly,
+                link = new better_sqlite3_1.default(filename, {
+                    readonly: !explicitWrite && !write,
                     fileMustExist,
                     timeout,
                     verbose,
                 });
-                this.connected = true;
-                this.link.pragma('encoding = "UTF-8";');
-                this.link.pragma('foreign_keys = 1;');
-                this.link.pragma('case_sensitive_like = 1;');
-                this.link.function('regexp', { deterministic: true }, (pattern, subject) => this.posixRegexMatch(pattern, subject) ? 1 : 0);
             }
             catch (e) {
-                this.connected = false;
-                if (filename === ':memory:') {
-                    throw new nymph_1.NotConfiguredError("It seems the config hasn't been set up correctly.");
+                if (e.code === 'SQLITE_CANTOPEN' &&
+                    !explicitWrite &&
+                    !write &&
+                    !this.config.fileMustExist) {
+                    const writeLink = new better_sqlite3_1.default(filename, {
+                        readonly: false,
+                        fileMustExist,
+                        timeout,
+                        verbose,
+                    });
+                    setOptions(writeLink);
+                    writeLink.close();
+                    link = new better_sqlite3_1.default(filename, {
+                        readonly: true,
+                        fileMustExist,
+                        timeout,
+                        verbose,
+                    });
                 }
                 else {
-                    throw new nymph_1.UnableToConnectError('Could not connect: ' + e?.message);
+                    throw e;
                 }
             }
+            if (!this.store) {
+                if (write) {
+                    throw new Error('Tried to open in write without opening in read first.');
+                }
+                this.store = new InternalStore(link);
+            }
+            else if (write) {
+                this.store.linkWrite = link;
+            }
+            else {
+                this.store.link = link;
+            }
+            this.store.connected = true;
+            setOptions(link);
+        }
+        catch (e) {
+            if (this.store) {
+                this.store.connected = false;
+            }
+            if (filename === ':memory:') {
+                throw new nymph_1.NotConfiguredError("It seems the config hasn't been set up correctly. Could not connect: " +
+                    e?.message);
+            }
+            else {
+                throw new nymph_1.UnableToConnectError('Could not connect: ' + e?.message);
+            }
         }
-        return this.connected;
     }
     async disconnect() {
-        if (this.connected) {
-            this.link.exec('PRAGMA optimize;');
-            this.link.close();
-            this.connected = false;
+        if (this.store.connected) {
+            if (this.store.linkWrite && !this.config.explicitWrite) {
+                this.store.linkWrite.exec('PRAGMA optimize;');
+                this.store.linkWrite.close();
+                this.store.linkWrite = undefined;
+            }
+            if (this.config.explicitWrite) {
+                this.store.link.exec('PRAGMA optimize;');
+            }
+            this.store.link.close();
+            this.store.transactionsStarted = 0;
+            this.store.connected = false;
         }
-        return this.connected;
+        return this.store.connected;
     }
     async inTransaction() {
-        return this.transactionsStarted > 0;
+        return this.store.transactionsStarted > 0;
     }
     isConnected() {
-        return this.connected;
-    }
-    checkReadOnlyMode() {
-        if (this.config.readonly) {
-            throw new nymph_1.InvalidParametersError('Attempt to write to SQLite3 DB in read only mode.');
-        }
+        return this.store.connected;
     }
     createTables(etype = null) {
-        this.checkReadOnlyMode();
         this.startTransaction('nymph-tablecreation');
         try {
             if (etype != null) {
@@ -96,13 +166,13 @@ class SQLite3Driver extends nymph_1.NymphDriver {
             else {
                 this.queryRun(`CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(`${this.prefix}uids`)} ("name" TEXT PRIMARY KEY NOT NULL, "cur_uid" INTEGER NOT NULL);`);
             }
-            this.commit('nymph-tablecreation');
-            return true;
         }
         catch (e) {
             this.rollback('nymph-tablecreation');
             throw e;
         }
+        this.commit('nymph-tablecreation');
+        return true;
     }
     query(runQuery, query, etypes = []) {
         try {
@@ -130,23 +200,32 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         }
     }
     queryIter(query, { etypes = [], params = {}, } = {}) {
-        return this.query(() => this.link.prepare(query).iterate(params), `${query} -- ${JSON.stringify(params)}`, etypes);
+        return this.query(() => (this.store.linkWrite || this.store.link)
+            .prepare(query)
+            .iterate(params), `${query} -- ${JSON.stringify(params)}`, etypes);
     }
     queryGet(query, { etypes = [], params = {}, } = {}) {
-        return this.query(() => this.link.prepare(query).get(params), `${query} -- ${JSON.stringify(params)}`, etypes);
+        return this.query(() => (this.store.linkWrite || this.store.link).prepare(query).get(params), `${query} -- ${JSON.stringify(params)}`, etypes);
     }
     queryRun(query, { etypes = [], params = {}, } = {}) {
-        return this.query(() => this.link.prepare(query).run(params), `${query} -- ${JSON.stringify(params)}`, etypes);
+        return this.query(() => (this.store.linkWrite || this.store.link).prepare(query).run(params), `${query} -- ${JSON.stringify(params)}`, etypes);
     }
     async commit(name) {
         if (name == null || typeof name !== 'string' || name.length === 0) {
             throw new nymph_1.InvalidParametersError('Transaction commit attempted without a name.');
         }
-        if (this.transactionsStarted === 0) {
+        if (this.store.transactionsStarted === 0) {
             return true;
         }
         this.queryRun(`RELEASE SAVEPOINT ${SQLite3Driver.escape(name)};`);
-        this.transactionsStarted--;
+        this.store.transactionsStarted--;
+        if (this.store.transactionsStarted === 0 &&
+            this.store.linkWrite &&
+            !this.config.explicitWrite) {
+            this.store.linkWrite.exec('PRAGMA optimize;');
+            this.store.linkWrite.close();
+            this.store.linkWrite = undefined;
+        }
         return true;
     }
     async deleteEntityByID(guid, className) {
@@ -159,7 +238,6 @@ class SQLite3Driver extends nymph_1.NymphDriver {
             EntityClass = className;
         }
         const etype = EntityClass.ETYPE;
-        this.checkReadOnlyMode();
         await this.startTransaction('nymph-delete');
         try {
             this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} WHERE "guid"=@guid;`, {
@@ -186,27 +264,28 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                     guid,
                 },
             });
-            await this.commit('nymph-delete');
-            if (this.nymph.config.cache) {
-                this.cleanCache(guid);
-            }
-            return true;
         }
         catch (e) {
             await this.rollback('nymph-delete');
             throw e;
         }
+        await this.commit('nymph-delete');
+        if (this.nymph.config.cache) {
+            this.cleanCache(guid);
+        }
+        return true;
     }
     async deleteUID(name) {
         if (!name) {
             throw new nymph_1.InvalidParametersError('Name not given for UID');
         }
-        this.checkReadOnlyMode();
+        await this.startTransaction('nymph-delete-uid');
         this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
             params: {
                 name,
             },
         });
+        await this.commit('nymph-delete-uid');
         return true;
     }
     async exportEntities(writeLine) {
@@ -274,6 +353,7 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         const cTable = `c${tableSuffix}`;
         const fTable = `f${tableSuffix}`;
         const ieTable = `ie${tableSuffix}`;
+        const sTable = `s${tableSuffix}`;
         const sort = options.sort ?? 'cdate';
         const queryParts = this.iterateSelectorsForQuery(formattedSelectors, (key, value, typeIsOr, typeIsNot) => {
             const clauseNot = key.startsWith('!');
@@ -1019,18 +1099,31 @@ class SQLite3Driver extends nymph_1.NymphDriver {
             return curQuery;
         });
         let sortBy;
+        let sortByInner;
+        let sortJoin = '';
+        const order = options.reverse ? ' DESC' : '';
         switch (sort) {
             case 'mdate':
-                sortBy = '"mdate"';
+                sortBy = `${eTable}."mdate"${order}`;
+                sortByInner = `${ieTable}."mdate"${order}`;
                 break;
             case 'cdate':
+                sortBy = `${eTable}."cdate"${order}`;
+                sortByInner = `${ieTable}."cdate"${order}`;
+                break;
             default:
-                sortBy = '"cdate"';
+                const name = `param${++count.i}`;
+                sortJoin = `LEFT JOIN (
+            SELECT "guid", "string", "number"
+            FROM ${SQLite3Driver.escape(this.prefix + 'comparisons_' + etype)}
+            WHERE "name"=@${name}
+            ORDER BY "number"${order}, "string"${order}
+          ) ${sTable} USING ("guid")`;
+                sortBy = `${sTable}."number"${order}, ${sTable}."string"${order}`;
+                sortByInner = sortBy;
+                params[name] = sort;
                 break;
         }
-        if (options.reverse) {
-            sortBy += ' DESC';
-        }
         let query;
         if (queryParts.length) {
             if (subquery) {
@@ -1063,8 +1156,9 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 else if (options.return === 'guid') {
                     query = `SELECT "guid"
             FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${ieTable}
+            ${sortJoin}
             WHERE (${whereClause})
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ORDER BY ${sortByInner}, "guid"${limit}${offset}`;
                 }
                 else {
                     query = `SELECT
@@ -1079,13 +1173,15 @@ class SQLite3Driver extends nymph_1.NymphDriver {
             FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${eTable}
             LEFT JOIN ${SQLite3Driver.escape(this.prefix + 'data_' + etype)} ${dTable} USING ("guid")
             INNER JOIN ${SQLite3Driver.escape(this.prefix + 'comparisons_' + etype)} ${cTable} USING ("guid", "name")
+            ${sortJoin}
             INNER JOIN (
               SELECT "guid"
               FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${ieTable}
+              ${sortJoin}
               WHERE (${whereClause})
-              ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+              ORDER BY ${sortByInner}${limit}${offset}
             ) ${fTable} USING ("guid")
-            ORDER BY ${eTable}.${sortBy}`;
+            ORDER BY ${sortBy}, ${eTable}."guid"`;
                 }
             }
         }
@@ -1117,7 +1213,8 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 else if (options.return === 'guid') {
                     query = `SELECT "guid"
             FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${ieTable}
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ${sortJoin}
+            ORDER BY ${sortByInner}, "guid"${limit}${offset}`;
                 }
                 else {
                     if (limit || offset) {
@@ -1133,12 +1230,14 @@ class SQLite3Driver extends nymph_1.NymphDriver {
               FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${eTable}
               LEFT JOIN ${SQLite3Driver.escape(this.prefix + 'data_' + etype)} ${dTable} USING ("guid")
               INNER JOIN ${SQLite3Driver.escape(this.prefix + 'comparisons_' + etype)} c USING ("guid", "name")
+              ${sortJoin}
               INNER JOIN (
                 SELECT "guid"
                 FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${ieTable}
-                ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+                ${sortJoin}
+                ORDER BY ${sortByInner}${limit}${offset}
               ) ${fTable} USING ("guid")
-              ORDER BY ${eTable}.${sortBy}`;
+              ORDER BY ${sortBy}, ${eTable}."guid"`;
                     }
                     else {
                         query = `SELECT
@@ -1153,7 +1252,8 @@ class SQLite3Driver extends nymph_1.NymphDriver {
               FROM ${SQLite3Driver.escape(this.prefix + 'entities_' + etype)} ${eTable}
               LEFT JOIN ${SQLite3Driver.escape(this.prefix + 'data_' + etype)} ${dTable} USING ("guid")
               INNER JOIN ${SQLite3Driver.escape(this.prefix + 'comparisons_' + etype)} ${cTable} USING ("guid", "name")
-              ORDER BY ${eTable}.${sortBy}`;
+              ${sortJoin}
+              ORDER BY ${sortBy}, ${eTable}."guid"`;
                     }
                 }
             }
@@ -1175,9 +1275,6 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         };
     }
     async getEntities(options = {}, ...selectors) {
-        return this.getEntitiesSync(options, ...selectors);
-    }
-    getEntitiesSync(options = {}, ...selectors) {
         const { result, process } = this.getEntitesRowLike(options, selectors, (options, formattedSelectors, etype) => this.performQuery(options, formattedSelectors, etype), () => {
             const next = result.next();
             return next.done ? null : next.value;
@@ -1211,7 +1308,6 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         return result?.cur_uid ?? null;
     }
     async import(filename) {
-        this.checkReadOnlyMode();
         try {
             return this.importFromFile(filename, async (guid, tags, sdata, etype) => {
                 this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} WHERE "guid"=@guid;`, {
@@ -1317,14 +1413,15 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         if (name == null) {
             throw new nymph_1.InvalidParametersError('Name not given for UID.');
         }
-        this.checkReadOnlyMode();
         await this.startTransaction('nymph-newuid');
+        let curUid = undefined;
         try {
-            let curUid = this.queryGet(`SELECT "cur_uid" FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
-                params: {
-                    name,
-                },
-            })?.cur_uid ?? null;
+            curUid =
+                this.queryGet(`SELECT "cur_uid" FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
+                    params: {
+                        name,
+                    },
+                })?.cur_uid ?? null;
             if (curUid == null) {
                 curUid = 1;
                 this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}uids`)} ("name", "cur_uid") VALUES (@name, @curUid);`, {
@@ -1343,40 +1440,47 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                     },
                 });
             }
-            await this.commit('nymph-newuid');
-            return curUid;
         }
         catch (e) {
             await this.rollback('nymph-newuid');
             throw e;
         }
+        await this.commit('nymph-newuid');
+        return curUid;
     }
     async renameUID(oldName, newName) {
         if (oldName == null || newName == null) {
             throw new nymph_1.InvalidParametersError('Name not given for UID.');
         }
-        this.checkReadOnlyMode();
+        await this.startTransaction('nymph-rename-uid');
         this.queryRun(`UPDATE ${SQLite3Driver.escape(`${this.prefix}uids`)} SET "name"=@newName WHERE "name"=@oldName;`, {
             params: {
                 newName,
                 oldName,
             },
         });
+        await this.commit('nymph-rename-uid');
         return true;
     }
     async rollback(name) {
         if (name == null || typeof name !== 'string' || name.length === 0) {
             throw new nymph_1.InvalidParametersError('Transaction rollback attempted without a name.');
         }
-        if (this.transactionsStarted === 0) {
+        if (this.store.transactionsStarted === 0) {
             return true;
         }
         this.queryRun(`ROLLBACK TO SAVEPOINT ${SQLite3Driver.escape(name)};`);
-        this.transactionsStarted--;
+        this.store.transactionsStarted--;
+        if (this.store.transactionsStarted === 0 &&
+            this.store.linkWrite &&
+            !this.config.explicitWrite) {
+            this.store.linkWrite.exec('PRAGMA optimize;');
+            this.store.linkWrite.close();
+            this.store.linkWrite = undefined;
+        }
         return true;
     }
     async saveEntity(entity) {
-        this.checkReadOnlyMode();
         const insertData = (guid, data, sdata, etype) => {
             const runInsertQuery = (name, value, svalue) => {
                 if (value === undefined) {
@@ -1424,8 +1528,13 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 runInsertQuery(name, JSON.parse(sdata[name]), sdata[name]);
             }
         };
+        let inTransaction = false;
         try {
             return this.saveEntityRowLike(entity, async (_entity, guid, tags, data, sdata, cdate, etype) => {
+                if (Object.keys(data).length === 0 &&
+                    Object.keys(sdata).length === 0) {
+                    return false;
+                }
                 this.queryRun(`INSERT INTO ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} ("guid", "tags", "cdate", "mdate") VALUES (@guid, @tags, @cdate, @cdate);`, {
                     etypes: [etype],
                     params: {
@@ -1437,6 +1546,10 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 insertData(guid, data, sdata, etype);
                 return true;
             }, async (entity, guid, tags, data, sdata, mdate, etype) => {
+                if (Object.keys(data).length === 0 &&
+                    Object.keys(sdata).length === 0) {
+                    return false;
+                }
                 const info = this.queryRun(`UPDATE ${SQLite3Driver.escape(`${this.prefix}entities_${etype}`)} SET "tags"=@tags, "mdate"=@mdate WHERE "guid"=@guid AND "mdate" <= @emdate;`, {
                     etypes: [etype],
                     params: {
@@ -1472,18 +1585,24 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 return success;
             }, async () => {
                 await this.startTransaction('nymph-save');
+                inTransaction = true;
             }, async (success) => {
-                if (success) {
-                    await this.commit('nymph-save');
-                }
-                else {
-                    await this.rollback('nymph-save');
+                if (inTransaction) {
+                    inTransaction = false;
+                    if (success) {
+                        await this.commit('nymph-save');
+                    }
+                    else {
+                        await this.rollback('nymph-save');
+                    }
                 }
                 return success;
             });
         }
         catch (e) {
-            await this.rollback('nymph-save');
+            if (inTransaction) {
+                await this.rollback('nymph-save');
+            }
             throw e;
         }
     }
@@ -1491,7 +1610,7 @@ class SQLite3Driver extends nymph_1.NymphDriver {
         if (name == null) {
             throw new nymph_1.InvalidParametersError('Name not given for UID.');
         }
-        this.checkReadOnlyMode();
+        await this.startTransaction('nymph-set-uid');
         this.queryRun(`DELETE FROM ${SQLite3Driver.escape(`${this.prefix}uids`)} WHERE "name"=@name;`, {
             params: {
                 name,
@@ -1503,14 +1622,18 @@ class SQLite3Driver extends nymph_1.NymphDriver {
                 curUid,
             },
         });
+        await this.commit('nymph-set-uid');
         return true;
     }
     async startTransaction(name) {
         if (name == null || typeof name !== 'string' || name.length === 0) {
             throw new nymph_1.InvalidParametersError('Transaction start attempted without a name.');
         }
+        if (!this.config.explicitWrite && !this.store.linkWrite) {
+            this._connect(true);
+        }
         this.queryRun(`SAVEPOINT ${SQLite3Driver.escape(name)};`);
-        this.transactionsStarted++;
+        this.store.transactionsStarted++;
         return this.nymph;
     }
 }