@capacitor-community/sqlite 5.6.0 → 5.6.1-1

package/dist/plugin.cjs.js

@@ -950,335 +950,11 @@ const CapacitorSQLite = core.registerPlugin('CapacitorSQLite', {
     electron: () => window.CapacitorCustomPlatform.plugins.CapacitorSQLite,
 });
 
-/************************************************
- * Only to be used to run TypeOrm Cli
- * migration:generate
- * A in-memory database is used
- ************************************************
- */
-class UtilsSQLite {
-    constructor() {
-        this.isExists = false;
-        this.retExists = { isExists: false, pathWasm: '' };
-        this.initSqlJs = require('sql.js');
-        this.OS = require('os');
-        this.FS = require('fs');
-        this.Path = require('path');
-    }
-    getTypeOrmDBFolder() {
-        // Find the index of the "node_modules" string in the path
-        const nodeModulesIndex = __dirname.indexOf('node_modules');
-        // Extract the part of the path before "node_modules"
-        const outputPath = __dirname.slice(0, nodeModulesIndex);
-        // Extract the App name
-        const appName = this.Path.basename(outputPath);
-        // Get the Documents path
-        const documentsDirectory = this.Path.join(this.OS.homedir(), 'Documents');
-        // Add "CapacitorSQLite" and appName
-        const outputFolderPath = this.Path.join(documentsDirectory, 'CapacitorSQLite', appName);
-        // Ensure the output folder exists
-        this.FS.mkdirSync(outputFolderPath, { recursive: true });
-        return outputFolderPath;
-    }
-    getTypeOrmDBPath(outputFolderPath, dbName) {
-        return this.Path.resolve(outputFolderPath, dbName);
-    }
-    async checkFileExistence(wasmPath) {
-        // check if a public folder exists
-        const folder = (await this.checkFolderExistence('public'))
-            ? 'public'
-            : 'src';
-        const pathWasm = this.Path.join(folder, wasmPath);
-        const retObj = {};
-        retObj.pathWasm = pathWasm;
-        try {
-            if (this.FS.existsSync(pathWasm)) {
-                retObj.isExists = true;
-                return Promise.resolve(retObj);
-            }
-            else {
-                retObj.isExists = false;
-                return Promise.resolve(retObj);
-            }
-        }
-        catch (err) {
-            retObj.isExists = false;
-            return Promise.resolve(retObj);
-        }
-    }
-    async checkFolderExistence(folder) {
-        try {
-            if (this.FS.existsSync(folder)) {
-                return Promise.resolve(true);
-            }
-            else {
-                return Promise.resolve(false);
-            }
-        }
-        catch (err) {
-            return Promise.resolve(false);
-        }
-    }
-    async openOrCreateDatabase(wasmPath, databasePath) {
-        let mDB;
-        const msg = 'OpenOrCreateDatabase';
-        try {
-            this.retExists = await this.checkFileExistence(wasmPath);
-            this.isExists = this.retExists.isExists;
-        }
-        catch (err) {
-            this.isExists = false;
-        }
-        if (!this.isExists) {
-            return Promise.reject(msg + ' No sql-wasm.wasm found in ' + wasmPath);
-        }
-        try {
-            const config = {
-                locateFile: (file) => `${this.retExists.pathWasm}/${file}`,
-            };
-            const SQL = await this.initSqlJs(config);
-            // Check if the database exists
-            if (!this.FS.existsSync(databasePath)) {
-                mDB = new SQL.Database();
-            }
-            else {
-                // Read the database file from the local disk
-                const fileBuffer = this.FS.readFileSync(databasePath);
-                // Create a new database instance
-                mDB = new SQL.Database(fileBuffer);
-            }
-            return Promise.resolve(mDB);
-        }
-        catch (err) {
-            return Promise.reject(msg + ' open database failed');
-        }
-    }
-    async saveDatabase(mDb, outputPath) {
-        try {
-            // Export the modified database to a Uint8Array
-            const data = mDb.export();
-            // Write the Uint8Array to a file on the local disk
-            this.FS.writeFileSync(outputPath, Buffer.from(data));
-            return Promise.resolve();
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-    }
-    closeDB(mDB) {
-        const msg = 'closeDB';
-        try {
-            mDB.close();
-            return Promise.resolve();
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            return Promise.reject(`${msg} ${errmsg}`);
-        }
-    }
-    async dbChanges(mDB) {
-        const SELECT_CHANGE = 'SELECT total_changes()';
-        let changes = 0;
-        try {
-            const res = mDB.exec(SELECT_CHANGE);
-            // process the row here
-            changes = res[0].values[0][0];
-            return Promise.resolve(changes);
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            return Promise.reject(`DbChanges failed: ${errmsg}`);
-        }
-    }
-    async getLastId(mDB) {
-        const SELECT_LAST_ID = 'SELECT last_insert_rowid()';
-        let lastId = -1;
-        try {
-            const res = mDB.exec(SELECT_LAST_ID);
-            // process the row here
-            lastId = res[0].values[0][0];
-            return Promise.resolve(lastId);
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            return Promise.reject(new Error(`GetLastId failed: ${errmsg}`));
-        }
-    }
-    async execute(mDB, sql) {
-        try {
-            mDB.exec(sql);
-            const changes = await this.dbChanges(mDB);
-            return Promise.resolve(changes);
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            return Promise.reject(new Error(`Execute failed: ${errmsg}`));
-        }
-    }
-    async run(mDB, statement, values, returnMode) {
-        let res;
-        let retValues = [];
-        const retObj = {};
-        try {
-            if (values.length > 0) {
-                res = mDB.exec(statement, values);
-            }
-            else {
-                res = mDB.exec(statement);
-            }
-            if (returnMode === 'all' || returnMode === 'one') {
-                if (res && res.length > 0) {
-                    retValues = this.getReturnedValues(res[0], returnMode);
-                }
-            }
-            const lastId = await this.getLastId(mDB);
-            retObj['lastId'] = lastId;
-            if (retValues != null && retValues.length > 0)
-                retObj['values'] = retValues;
-            return Promise.resolve(retObj);
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            return Promise.reject(new Error(`Run failed: ${errmsg}`));
-        }
-    }
-    getReturnedValues(result, returnMode) {
-        const retValues = [];
-        for (const values of result.values) {
-            const row = {};
-            for (let j = 0; j < result.columns.length; j++) {
-                row[result.columns[j]] = values[j];
-            }
-            retValues.push(row);
-            if (returnMode === 'one') {
-                break;
-            }
-        }
-        return retValues;
-    }
-    async queryAll(mDB, sql, values) {
-        try {
-            let retArr = [];
-            if (values != null && values.length > 0) {
-                retArr = mDB.exec(sql, values);
-            }
-            else {
-                retArr = mDB.exec(sql);
-            }
-            if (retArr.length == 0)
-                return Promise.resolve([]);
-            const result = retArr[0].values.map((entry) => {
-                const obj = {};
-                retArr[0].columns.forEach((column, index) => {
-                    obj[`${column}`] = entry[index];
-                });
-                return obj;
-            });
-            return Promise.resolve(result);
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            return Promise.reject(new Error(`queryAll: ${errmsg}`));
-        }
-    }
-}
-
-/************************************************
- * Only to be used to run TypeOrm Cli
- * migration:generate
- * A in-memory database is used
- ************************************************
- */
-class Database {
-    constructor() {
-        this.wasmPath = 'assets';
-        this.sqliteUtil = new UtilsSQLite();
-        this.typeOrmDBFolder = this.sqliteUtil.getTypeOrmDBFolder();
-        this.dbPath = '';
-        this.mDb = null;
-        this._isDBOpen = false;
-    }
-    async open(dbName) {
-        try {
-            this.dbPath = this.sqliteUtil.getTypeOrmDBPath(this.typeOrmDBFolder, `${dbName}SQLite.db`);
-            this.mDb = await this.sqliteUtil.openOrCreateDatabase(this.wasmPath, this.dbPath);
-            this._isDBOpen = true;
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`Open: ${err}`);
-        }
-    }
-    async close() {
-        try {
-            if (this._isDBOpen) {
-                await this.sqliteUtil.saveDatabase(this.mDb, this.dbPath);
-                await this.mDb.close();
-            }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`Close: ${err}`);
-        }
-    }
-    async executeSQL(statements) {
-        let changes = -1;
-        try {
-            if (this._isDBOpen) {
-                const initChanges = await this.sqliteUtil.dbChanges(this.mDb);
-                changes = await this.sqliteUtil.execute(this.mDb, statements);
-                if (changes < 0) {
-                    return Promise.reject(new Error('ExecuteSQL: changes < 0'));
-                }
-                changes = (await this.sqliteUtil.dbChanges(this.mDb)) - initChanges;
-            }
-            return Promise.resolve(changes);
-        }
-        catch (err) {
-            return Promise.reject(`ExecuteSQL: ${err}`);
-        }
-    }
-    async run(statement, values, returnMode) {
-        const retRes = { changes: -1, lastId: -1 };
-        try {
-            if (this._isDBOpen) {
-                const initChanges = await this.sqliteUtil.dbChanges(this.mDb);
-                const retObj = await this.sqliteUtil.run(this.mDb, statement, values, returnMode);
-                const lastId = retObj['lastId'];
-                if (lastId < 0) {
-                    return Promise.reject(new Error('RunSQL: lastId < 0'));
-                }
-                const changes = (await this.sqliteUtil.dbChanges(this.mDb)) - initChanges;
-                retRes.changes = changes;
-                retRes.lastId = lastId;
-                retRes.values = retObj['values'] ? retObj['values'] : [];
-            }
-            return Promise.resolve({ changes: retRes });
-        }
-        catch (err) {
-            return Promise.reject(`Run: ${err}`);
-        }
-    }
-    async selectSQL(sql, values) {
-        let retArr = [];
-        try {
-            if (this._isDBOpen) {
-                retArr = await this.sqliteUtil.queryAll(this.mDb, sql, values);
-            }
-            return Promise.resolve({ values: retArr });
-        }
-        catch (err) {
-            return Promise.reject(`SelectSQL: ${err}`);
-        }
-    }
-}
-
 class CapacitorSQLiteWeb extends core.WebPlugin {
     constructor() {
         super(...arguments);
         this.jeepSqliteElement = null;
         this.isWebStoreOpen = false;
-        this.databases = {};
     }
     async initWebStore() {
         await customElements.whenDefined('jeep-sqlite');
@@ -1343,88 +1019,36 @@ class CapacitorSQLiteWeb extends core.WebPlugin {
         return echoResult;
     }
     async createConnection(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                await this.jeepSqliteElement.createConnection(options);
-                return;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.createConnection(options);
+            return;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const optionKeys = Object.keys(options);
-            let dbName;
-            if (!optionKeys.includes('database')) {
-                throw new Error('Must provide a database name');
-            }
-            else {
-                dbName = options.database;
-            }
-            const connName = 'RW_' + dbName;
-            const databaseConnection = new Database();
-            this.databases[connName] = databaseConnection;
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async open(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                await this.jeepSqliteElement.open(options);
-                return;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.open(options);
+            return;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const dbName = options.database ? options.database : '';
-            if (dbName.length === 0) {
-                throw new Error('Must provide a database name');
-            }
-            const connName = 'RW_' + dbName;
-            const database = this.getDatabaseConnectionOrThrowError(connName);
-            try {
-                await database.open(dbName);
-            }
-            catch (err) {
-                throw new Error(`### open ${err}`);
-            }
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async closeConnection(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                await this.jeepSqliteElement.closeConnection(options);
-                return;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.closeConnection(options);
+            return;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const dbName = options.database ? options.database : '';
-            if (dbName.length === 0) {
-                throw new Error('Must provide a database name');
-            }
-            const connName = 'RW_' + dbName;
-            const database = this.getDatabaseConnectionOrThrowError(connName);
-            try {
-                await database.close();
-                // remove the connection from dictionary
-                delete this.databases[connName];
-            }
-            catch (err) {
-                throw new Error(`### closeConnection ${err}`);
-            }
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async getVersion(options) {
@@ -1449,31 +1073,14 @@ class CapacitorSQLiteWeb extends core.WebPlugin {
         }
     }
     async close(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                await this.jeepSqliteElement.close(options);
-                return;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            await this.jeepSqliteElement.close(options);
+            return;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const dbName = options.database ? options.database : '';
-            if (dbName.length === 0) {
-                throw new Error('Must provide a database name');
-            }
-            const connName = 'RW_' + dbName;
-            const database = this.getDatabaseConnectionOrThrowError(connName);
-            try {
-                await database.close();
-            }
-            catch (err) {
-                throw new Error(`### close ${err}`);
-            }
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async beginTransaction(options) {
@@ -1532,37 +1139,14 @@ class CapacitorSQLiteWeb extends core.WebPlugin {
         }
     }
     async execute(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                const executeResult = await this.jeepSqliteElement.execute(options);
-                return executeResult;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const executeResult = await this.jeepSqliteElement.execute(options);
+            return executeResult;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const dbName = options.database ? options.database : '';
-            if (dbName.length === 0) {
-                throw new Error('Must provide a database name');
-            }
-            const statements = options.statements ? options.statements : '';
-            if (statements.length === 0) {
-                return Promise.reject('Must provide raw SQL statements');
-            }
-            const connName = 'RW_' + dbName;
-            const database = this.getDatabaseConnectionOrThrowError(connName);
-            try {
-                const ret = await database.executeSQL(statements);
-                const executeResult = { changes: { changes: ret } };
-                return executeResult;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async executeSet(options) {
@@ -1577,72 +1161,25 @@ class CapacitorSQLiteWeb extends core.WebPlugin {
         }
     }
     async run(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                const runResult = await this.jeepSqliteElement.run(options);
-                return runResult;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const runResult = await this.jeepSqliteElement.run(options);
+            return runResult;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const dbName = options.database ? options.database : '';
-            if (dbName.length === 0) {
-                throw new Error('Must provide a database name');
-            }
-            const statement = options.statement ? options.statement : '';
-            if (statement.length === 0) {
-                return Promise.reject('Must provide raw SQL statement');
-            }
-            const values = options.values ? options.values : [];
-            const returnMode = options.returnMode ? options.returnMode : 'no';
-            const connName = 'RW_' + dbName;
-            const database = this.getDatabaseConnectionOrThrowError(connName);
-            try {
-                const runResult = await database.run(statement, values, returnMode);
-                return runResult;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async query(options) {
-        if (typeof window !== 'undefined' && window.document) {
-            this.ensureJeepSqliteIsAvailable();
-            this.ensureWebstoreIsOpen();
-            try {
-                const queryResult = await this.jeepSqliteElement.query(options);
-                return queryResult;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        this.ensureJeepSqliteIsAvailable();
+        this.ensureWebstoreIsOpen();
+        try {
+            const queryResult = await this.jeepSqliteElement.query(options);
+            return queryResult;
         }
-        else {
-            // Only for typeOrm to run migration:generate
-            const dbName = options.database ? options.database : '';
-            if (dbName.length === 0) {
-                throw new Error('Must provide a database name');
-            }
-            const statement = options.statement ? options.statement : '';
-            if (statement.length === 0) {
-                return Promise.reject('Must provide raw SQL statement');
-            }
-            const values = options.values ? options.values : [];
-            const connName = 'RW_' + dbName;
-            const database = this.getDatabaseConnectionOrThrowError(connName);
-            try {
-                const queryResult = await database.selectSQL(statement, values);
-                return queryResult;
-            }
-            catch (err) {
-                throw new Error(`${err}`);
-            }
+        catch (err) {
+            throw new Error(`${err}`);
         }
     }
     async isDBExists(options) {
@@ -1841,13 +1378,6 @@ class CapacitorSQLiteWeb extends core.WebPlugin {
             throw new Error('WebStore is not open yet. You have to call "initWebStore()" first.');
         }
     }
-    getDatabaseConnectionOrThrowError(dbName) {
-        const databaseNames = Object.keys(this.databases);
-        if (!databaseNames.includes(dbName)) {
-            throw new Error(`No connection available for database "${dbName}"`);
-        }
-        return this.databases[dbName];
-    }
     ////////////////////////////////////
     ////// UNIMPLEMENTED METHODS
     ////////////////////////////////////