Socket
Socket
Sign inDemoInstall

jeep-sqlite

Package Overview
Dependencies
Maintainers
1
Versions
104
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

jeep-sqlite - npm Package Compare versions

Comparing version 2.5.4 to 2.5.5

dist/cjs/index-0ceba7e1.js
dist/cjs/index-0ceba7e1.js.map
dist/esm/index-ffc65f19.js
dist/esm/index-ffc65f19.js.map
dist/jeep-sqlite/p-8938a358.js
dist/jeep-sqlite/p-8938a358.js.map
dist/jeep-sqlite/p-f47f1152.entry.js
dist/jeep-sqlite/p-f47f1152.entry.js.map

4

dist/cjs/jeep-sqlite.cjs.js

@@ -5,6 +5,6 @@ 'use strict';

const index = require('./index-75f3d9d3.js');
const index = require('./index-0ceba7e1.js');
/*
Stencil Client Patch Browser v4.3.0 | MIT Licensed | https://stenciljs.com
Stencil Client Patch Browser v4.9.0 | MIT Licensed | https://stenciljs.com
*/

@@ -11,0 +11,0 @@ const patchBrowser = () => {

2

dist/cjs/loader.cjs.js

@@ -5,3 +5,3 @@ 'use strict';

const index = require('./index-75f3d9d3.js');
const index = require('./index-0ceba7e1.js');

@@ -8,0 +8,0 @@ const defineCustomElements = (win, options) => {

4

dist/collection/collection-manifest.json

@@ -7,4 +7,4 @@ {

"name": "@stencil/core",
"version": "4.3.0",
"typescriptVersion": "5.1.6"
"version": "4.9.0",
"typescriptVersion": "5.2.2"
},

@@ -11,0 +11,0 @@ "collections": [],

12

dist/collection/components/jeep-sqlite/jeep-sqlite.e2e.js
import { newE2EPage } from "@stencil/core/testing";
describe('jeep-sqlite', () => {
it('renders', async () => {
const page = await newE2EPage();
await page.setContent('<jeep-sqlite></jeep-sqlite>');
const element = await page.find('jeep-sqlite');
expect(element).toHaveClass('hydrated');
});
it('renders', async () => {
const page = await newE2EPage();
await page.setContent('<jeep-sqlite></jeep-sqlite>');
const element = await page.find('jeep-sqlite');
expect(element).toHaveClass('hydrated');
});
});
//# sourceMappingURL=jeep-sqlite.e2e.js.map

26

dist/collection/components/jeep-sqlite/jeep-sqlite.spec.js
import { newSpecPage } from "@stencil/core/testing";
import { JeepSqlite } from "./jeep-sqlite";
describe('jeep-sqlite', () => {
it('renders', async () => {
const { root } = await newSpecPage({
components: [JeepSqlite],
html: '<jeep-sqlite></jeep-sqlite>',
});
expect(root).toEqualHtml(`
it('renders', async () => {
const { root } = await newSpecPage({
components: [JeepSqlite],
html: '<jeep-sqlite></jeep-sqlite>',
});
expect(root).toEqualHtml(`
<jeep-sqlite>

@@ -15,9 +15,9 @@ <mock:shadow-root>

`);
});
it('renders with values', async () => {
const { root } = await newSpecPage({
components: [JeepSqlite],
html: `<jeep-sqlite></jeep-sqlite>`,
});
expect(root).toEqualHtml(`
it('renders with values', async () => {
const { root } = await newSpecPage({
components: [JeepSqlite],
html: `<jeep-sqlite></jeep-sqlite>`,
});
expect(root).toEqualHtml(`
<jeep-sqlite>

@@ -28,4 +28,4 @@ <mock:shadow-root>

`);
});
});
});
//# sourceMappingURL=jeep-sqlite.spec.js.map

1118

dist/collection/utils/database.js

@@ -9,466 +9,466 @@ import initSqlJs from "sql.js";

export class Database {
constructor(databaseName, version, upgDict, store, autoSave, wasmPath) {
this.vUpgDict = {};
this.autoSave = false;
this.wasmPath = '/assets';
this.isBackup = false;
this.isTransactionActive = false;
this.dbName = databaseName;
this.store = store;
this.version = version;
this.mDb = null;
this.vUpgDict = upgDict;
this._isDBOpen = false;
this.autoSave = autoSave;
this.wasmPath = wasmPath;
}
async open() {
const config = {
locateFile: (file) => `${this.wasmPath}/${file}`
};
return new Promise((resolve, reject) => {
try {
initSqlJs(config).then(async (SQL) => {
// retrieve the database if stored on localforage
const retDB = await UtilsStore.getDBFromStore(this.dbName, this.store);
if (retDB != null) {
// Open existing database
this.mDb = new SQL.Database(retDB);
}
else {
// Create a new database
this.mDb = new SQL.Database();
await UtilsStore.setInitialDBToStore(this.dbName, this.store);
}
this._isDBOpen = true;
// get the current version
let curVersion = await UtilsSQLite.getVersion(this.mDb);
if (this.version > curVersion && (Object.keys(this.vUpgDict)).length > 0) {
constructor(databaseName, version, upgDict, store, autoSave, wasmPath) {
this.vUpgDict = {};
this.autoSave = false;
this.wasmPath = '/assets';
this.isBackup = false;
this.isTransactionActive = false;
this.dbName = databaseName;
this.store = store;
this.version = version;
this.mDb = null;
this.vUpgDict = upgDict;
this._isDBOpen = false;
this.autoSave = autoSave;
this.wasmPath = wasmPath;
}
async open() {
const config = {
locateFile: (file) => `${this.wasmPath}/${file}`
};
return new Promise((resolve, reject) => {
try {
// copy the db
const isDB = await UtilsStore.isDBInStore(this.dbName, this.store);
if (isDB) {
await UtilsStore.copyDBToStore(this.dbName, `backup-${this.dbName}`, this.store);
this.isBackup = true;
}
// execute the upgrade flow process
const changes = await UtilsUpgrade.onUpgrade(this, this.vUpgDict, curVersion, this.version);
if (changes === -1) {
// restore the database from backup
try {
if (this.isBackup) {
await UtilsStore.restoreDBFromStore(this.dbName, 'backup', this.store);
}
}
catch (err) {
return reject(new Error(`Open: ${err.message}`));
}
}
// delete the backup database
if (this.isBackup) {
await UtilsStore.removeDBFromStore(`backup-${this.dbName}`, this.store);
}
initSqlJs(config).then(async (SQL) => {
// retrieve the database if stored on localforage
const retDB = await UtilsStore.getDBFromStore(this.dbName, this.store);
if (retDB != null) {
// Open existing database
this.mDb = new SQL.Database(retDB);
}
else {
// Create a new database
this.mDb = new SQL.Database();
await UtilsStore.setInitialDBToStore(this.dbName, this.store);
}
this._isDBOpen = true;
// get the current version
let curVersion = await UtilsSQLite.getVersion(this.mDb);
if (this.version > curVersion && (Object.keys(this.vUpgDict)).length > 0) {
try {
// copy the db
const isDB = await UtilsStore.isDBInStore(this.dbName, this.store);
if (isDB) {
await UtilsStore.copyDBToStore(this.dbName, `backup-${this.dbName}`, this.store);
this.isBackup = true;
}
// execute the upgrade flow process
const changes = await UtilsUpgrade.onUpgrade(this, this.vUpgDict, curVersion, this.version);
if (changes === -1) {
// restore the database from backup
try {
if (this.isBackup) {
await UtilsStore.restoreDBFromStore(this.dbName, 'backup', this.store);
}
}
catch (err) {
return reject(new Error(`Open: ${err.message}`));
}
}
// delete the backup database
if (this.isBackup) {
await UtilsStore.removeDBFromStore(`backup-${this.dbName}`, this.store);
}
}
catch (err) {
// restore the database from backup
try {
if (this.isBackup) {
await UtilsStore.restoreDBFromStore(this.dbName, 'backup', this.store);
}
}
catch (err) {
return reject(new Error(`Open: ${err.message}`));
}
}
}
if (this.autoSave) {
try {
await this.saveToStore();
}
catch (err) {
this._isDBOpen = false;
return reject(`Open: ${err}`);
}
}
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, true);
return resolve();
});
}
catch (err) {
// restore the database from backup
try {
if (this.isBackup) {
await UtilsStore.restoreDBFromStore(this.dbName, 'backup', this.store);
}
}
catch (err) {
return reject(new Error(`Open: ${err.message}`));
}
this._isDBOpen = false;
return reject(`in open ${err}`);
}
}
if (this.autoSave) {
});
}
isDBOpen() {
return this._isDBOpen;
}
async close() {
if (this.mDb != null && this._isDBOpen) {
try {
await this.saveToStore();
// save the database to store
await this.saveToStore(false);
// close the database
this.mDb.close();
this._isDBOpen = false;
}
catch (err) {
this._isDBOpen = false;
return reject(`Open: ${err}`);
this._isDBOpen = false;
return Promise.reject(`in close ${err}`);
}
}
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, true);
return resolve();
});
}
catch (err) {
this._isDBOpen = false;
return reject(`in open ${err}`);
}
});
}
isDBOpen() {
return this._isDBOpen;
}
async close() {
if (this.mDb != null && this._isDBOpen) {
try {
// save the database to store
await this.saveToStore(false);
// close the database
this.mDb.close();
this._isDBOpen = false;
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`in close ${err}`);
}
}
return Promise.resolve();
}
return Promise.resolve();
}
async saveToStore(setFK = true) {
if (this.mDb != null && this._isDBOpen) {
try {
// save the database to store
await UtilsStore.setDBToStore(this.mDb, this.dbName, this.store);
if (setFK) {
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, true);
async saveToStore(setFK = true) {
if (this.mDb != null && this._isDBOpen) {
try {
// save the database to store
await UtilsStore.setDBToStore(this.mDb, this.dbName, this.store);
if (setFK) {
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, true);
}
}
catch (err) {
return Promise.reject(`in saveToStore ${err}`);
}
}
}
catch (err) {
return Promise.reject(`in saveToStore ${err}`);
}
return Promise.resolve();
}
return Promise.resolve();
}
async exportDB() {
// export the database
try {
const data = this.mDb.export();
return data;
async exportDB() {
// export the database
try {
const data = this.mDb.export();
return data;
}
catch (err) {
const msg = err.message ? err.message : err;
return Promise.reject(`exportDB: ${msg}`);
}
}
catch (err) {
const msg = err.message ? err.message : err;
return Promise.reject(`exportDB: ${msg}`);
async getVersion() {
if (this.mDb != null && this._isDBOpen) {
try {
// save the database to store
const curVersion = await UtilsSQLite.getVersion(this.mDb);
return Promise.resolve(curVersion);
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`in getVersion ${err}`);
}
}
}
}
async getVersion() {
if (this.mDb != null && this._isDBOpen) {
try {
// save the database to store
const curVersion = await UtilsSQLite.getVersion(this.mDb);
return Promise.resolve(curVersion);
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`in getVersion ${err}`);
}
async isDBExists(database) {
try {
const isExists = await UtilsStore.isDBInStore(database, this.store);
return Promise.resolve(isExists);
}
catch (err) {
return Promise.reject(`in isDBExists ${err}`);
}
}
}
async isDBExists(database) {
try {
const isExists = await UtilsStore.isDBInStore(database, this.store);
return Promise.resolve(isExists);
async deleteDB(database) {
try {
// test if file exists
const isExists = await this.isDBExists(database);
if (isExists && !this._isDBOpen) {
// open the database
await this.open();
}
// close the database
await this.close();
// delete the database
if (isExists) {
await UtilsStore.removeDBFromStore(database, this.store);
}
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DeleteDB: ${err.message}`));
}
}
catch (err) {
return Promise.reject(`in isDBExists ${err}`);
async beginTransaction() {
if (!this._isDBOpen) {
let msg = `BeginTransaction: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
await UtilsSQLite.beginTransaction(this.mDb, true);
this.setIsTransActive(true);
return 0;
}
catch (err) {
let msg = `BeginTransaction: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
}
}
async deleteDB(database) {
try {
// test if file exists
const isExists = await this.isDBExists(database);
if (isExists && !this._isDBOpen) {
// open the database
await this.open();
}
// close the database
await this.close();
// delete the database
if (isExists) {
await UtilsStore.removeDBFromStore(database, this.store);
}
return Promise.resolve();
async commitTransaction() {
if (!this._isDBOpen) {
let msg = `CommitTransaction: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
await UtilsSQLite.commitTransaction(this.mDb, true);
this.setIsTransActive(false);
return 0;
}
catch (err) {
let msg = `CommitTransaction: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
}
catch (err) {
return Promise.reject(new Error(`DeleteDB: ${err.message}`));
async rollbackTransaction() {
if (!this._isDBOpen) {
let msg = `RollbackTransaction: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
await UtilsSQLite.rollbackTransaction(this.mDb, true);
this.setIsTransActive(false);
return 0;
}
catch (err) {
let msg = `RollbackTransaction: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
}
}
async beginTransaction() {
if (!this._isDBOpen) {
let msg = `BeginTransaction: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
isTransActive() {
return this.isTransactionActive;
}
try {
await UtilsSQLite.beginTransaction(this.mDb, true);
this.setIsTransActive(true);
return 0;
setIsTransActive(value) {
this.isTransactionActive = value;
}
catch (err) {
let msg = `BeginTransaction: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
async executeSQL(sql, transaction = true) {
if (!this._isDBOpen) {
let msg = `ExecuteSQL: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
let initChanges = -1;
try {
initChanges = await UtilsSQLite.dbChanges(this.mDb);
if (transaction && !this.isTransactionActive) {
await this.beginTransaction();
}
}
catch (err) {
let msg = `executeSQL: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
try {
const mChanges = await UtilsSQLite.execute(this.mDb, sql, false);
if (mChanges < 0) {
return Promise.reject(new Error('ExecuteSQL: changes < 0'));
}
if (transaction && this.isTransactionActive) {
await this.commitTransaction();
}
const changes = (await UtilsSQLite.dbChanges(this.mDb)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
let msg = `ExecuteSQL: ${err.message}`;
try {
if (transaction && this.isTransactionActive)
await this.rollbackTransaction();
}
catch (err) {
msg += ` : ${err.message}`;
}
return Promise.reject(new Error(`ExecuteSQL: ${msg}`));
}
finally {
if (transaction)
this.isTransactionActive = false;
if (this.autoSave) {
try {
await this.saveToStore();
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`ExecuteSQL: ${err}`);
}
}
}
}
}
async commitTransaction() {
if (!this._isDBOpen) {
let msg = `CommitTransaction: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
async execSet(set, transaction = true, returnMode = 'no') {
if (!this._isDBOpen) {
let msg = `ExecSet: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
const retRes = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
initChanges = await UtilsSQLite.dbChanges(this.mDb);
if (transaction && !this.isTransactionActive) {
await this.beginTransaction();
}
}
catch (err) {
let msg = `ExecSet: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
try {
const retObj = await UtilsSQLite.executeSet(this.mDb, set, false, returnMode);
let lastId = retObj["lastId"];
if (lastId < 0) {
return Promise.reject(new Error('ExecSet: changes < 0'));
}
if (transaction && this.isTransactionActive)
await this.commitTransaction();
const changes = (await UtilsSQLite.dbChanges(this.mDb)) - initChanges;
retRes.changes = changes;
retRes.lastId = lastId;
retRes.values = retObj["values"] ? retObj["values"] : [];
return Promise.resolve(retRes);
}
catch (err) {
let msg = `ExecSet: ${err.message}`;
try {
if (transaction && this.isTransactionActive)
await this.rollbackTransaction();
}
catch (err) {
msg += ` : ${err.message}`;
}
return Promise.reject(new Error(`ExecSet: ${msg}`));
}
finally {
if (transaction)
this.isTransactionActive = false;
if (this.autoSave) {
try {
await this.saveToStore();
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`ExecSet: ${err}`);
}
}
}
}
try {
await UtilsSQLite.commitTransaction(this.mDb, true);
this.setIsTransActive(false);
return 0;
async selectSQL(sql, values) {
if (!this._isDBOpen) {
let msg = `SelectSQL: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
let retArr = await UtilsSQLite.queryAll(this.mDb, sql, values);
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`SelectSQL: ${err.message}`));
}
}
catch (err) {
let msg = `CommitTransaction: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
}
async rollbackTransaction() {
if (!this._isDBOpen) {
let msg = `RollbackTransaction: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
await UtilsSQLite.rollbackTransaction(this.mDb, true);
this.setIsTransActive(false);
return 0;
}
catch (err) {
let msg = `RollbackTransaction: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
}
isTransActive() {
return this.isTransactionActive;
}
setIsTransActive(value) {
this.isTransactionActive = value;
}
async executeSQL(sql, transaction = true) {
if (!this._isDBOpen) {
let msg = `ExecuteSQL: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
let initChanges = -1;
try {
initChanges = await UtilsSQLite.dbChanges(this.mDb);
if (transaction && !this.isTransactionActive) {
await this.beginTransaction();
}
}
catch (err) {
let msg = `executeSQL: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
try {
const mChanges = await UtilsSQLite.execute(this.mDb, sql, false);
if (mChanges < 0) {
return Promise.reject(new Error('ExecuteSQL: changes < 0'));
}
if (transaction && this.isTransactionActive) {
await this.commitTransaction();
}
const changes = (await UtilsSQLite.dbChanges(this.mDb)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
let msg = `ExecuteSQL: ${err.message}`;
try {
if (transaction && this.isTransactionActive)
await this.rollbackTransaction();
}
catch (err) {
msg += ` : ${err.message}`;
}
return Promise.reject(new Error(`ExecuteSQL: ${msg}`));
}
finally {
if (transaction)
this.isTransactionActive = false;
if (this.autoSave) {
async runSQL(statement, values, transaction = true, returnMode) {
let lastId = -1;
if (!this._isDBOpen) {
let msg = `RunSQL: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
const retRes = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
await this.saveToStore();
initChanges = await UtilsSQLite.dbChanges(this.mDb);
if (transaction && !this.isTransactionActive) {
await this.beginTransaction();
}
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`ExecuteSQL: ${err}`);
let msg = `RunSQL: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
}
try {
const retObj = await UtilsSQLite.run(this.mDb, statement, values, false, returnMode);
lastId = retObj["lastId"];
if (lastId < 0) {
return Promise.reject(new Error('RunSQL: lastId < 0'));
}
if (transaction && this.isTransactionActive) {
await this.commitTransaction();
}
const changes = (await UtilsSQLite.dbChanges(this.mDb)) - initChanges;
retRes.changes = changes;
retRes.lastId = lastId;
retRes.values = retObj["values"] ? retObj["values"] : [];
return Promise.resolve(retRes);
}
catch (err) {
let msg = `RunSQL: ${err.message}`;
try {
if (transaction && this.isTransactionActive) {
await this.rollbackTransaction();
}
}
catch (err) {
msg += ` : ${err.message}`;
}
return Promise.reject(new Error(`${msg}`));
}
finally {
if (transaction)
this.setIsTransActive(false);
if (this.autoSave) {
try {
await this.saveToStore();
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`ExecSet: ${err}`);
}
}
}
}
}
async execSet(set, transaction = true, returnMode = 'no') {
if (!this._isDBOpen) {
let msg = `ExecSet: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
const retRes = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
initChanges = await UtilsSQLite.dbChanges(this.mDb);
if (transaction && !this.isTransactionActive) {
await this.beginTransaction();
}
}
catch (err) {
let msg = `ExecSet: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
try {
const retObj = await UtilsSQLite.executeSet(this.mDb, set, false, returnMode);
let lastId = retObj["lastId"];
if (lastId < 0) {
return Promise.reject(new Error('ExecSet: changes < 0'));
}
if (transaction && this.isTransactionActive)
await this.commitTransaction();
const changes = (await UtilsSQLite.dbChanges(this.mDb)) - initChanges;
retRes.changes = changes;
retRes.lastId = lastId;
retRes.values = retObj["values"] ? retObj["values"] : [];
return Promise.resolve(retRes);
}
catch (err) {
let msg = `ExecSet: ${err.message}`;
try {
if (transaction && this.isTransactionActive)
await this.rollbackTransaction();
}
catch (err) {
msg += ` : ${err.message}`;
}
return Promise.reject(new Error(`ExecSet: ${msg}`));
}
finally {
if (transaction)
this.isTransactionActive = false;
if (this.autoSave) {
async getTableNames() {
if (!this._isDBOpen) {
let msg = `GetTableNames: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
await this.saveToStore();
let retArr = await UtilsSQLite.getTableList(this.mDb);
return Promise.resolve(retArr);
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`ExecSet: ${err}`);
return Promise.reject(new Error(`GetTableNames: ${err.message}`));
}
}
}
}
async selectSQL(sql, values) {
if (!this._isDBOpen) {
let msg = `SelectSQL: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
let retArr = await UtilsSQLite.queryAll(this.mDb, sql, values);
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`SelectSQL: ${err.message}`));
}
}
async runSQL(statement, values, transaction = true, returnMode) {
let lastId = -1;
if (!this._isDBOpen) {
let msg = `RunSQL: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
const retRes = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
initChanges = await UtilsSQLite.dbChanges(this.mDb);
if (transaction && !this.isTransactionActive) {
await this.beginTransaction();
}
}
catch (err) {
let msg = `RunSQL: ${err.message}`;
return Promise.reject(new Error(`${msg}`));
}
try {
const retObj = await UtilsSQLite.run(this.mDb, statement, values, false, returnMode);
lastId = retObj["lastId"];
if (lastId < 0) {
return Promise.reject(new Error('RunSQL: lastId < 0'));
}
if (transaction && this.isTransactionActive) {
await this.commitTransaction();
}
const changes = (await UtilsSQLite.dbChanges(this.mDb)) - initChanges;
retRes.changes = changes;
retRes.lastId = lastId;
retRes.values = retObj["values"] ? retObj["values"] : [];
return Promise.resolve(retRes);
}
catch (err) {
let msg = `RunSQL: ${err.message}`;
try {
if (transaction && this.isTransactionActive) {
await this.rollbackTransaction();
async isTable(tableName) {
if (!this._isDBOpen) {
let msg = `isTable: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
}
catch (err) {
msg += ` : ${err.message}`;
}
return Promise.reject(new Error(`${msg}`));
}
finally {
if (transaction)
this.setIsTransActive(false);
if (this.autoSave) {
try {
await this.saveToStore();
const retB = await UtilsSQLite.isTableExists(this.mDb, tableName);
return Promise.resolve(retB);
}
catch (err) {
this._isDBOpen = false;
return Promise.reject(`ExecSet: ${err}`);
const msg = `IsTable: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
}
}
async getTableNames() {
if (!this._isDBOpen) {
let msg = `GetTableNames: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
let retArr = await UtilsSQLite.getTableList(this.mDb);
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`GetTableNames: ${err.message}`));
}
}
async isTable(tableName) {
if (!this._isDBOpen) {
let msg = `isTable: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
const retB = await UtilsSQLite.isTableExists(this.mDb, tableName);
return Promise.resolve(retB);
}
catch (err) {
const msg = `IsTable: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
async createSyncTable() {
if (!this._isDBOpen) {
let msg = `createSyncTable: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
let changes = -1;
try {
const retB = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (!retB) {
const isLastMod = await UtilsSQLite.isLastModified(this.mDb, this._isDBOpen);
const isDel = await UtilsSQLite.isSqlDeleted(this.mDb, this._isDBOpen);
if (isLastMod && isDel) {
const date = Math.round(new Date().getTime() / 1000);
let stmts = `
async createSyncTable() {
if (!this._isDBOpen) {
let msg = `createSyncTable: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
let changes = -1;
try {
const retB = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (!retB) {
const isLastMod = await UtilsSQLite.isLastModified(this.mDb, this._isDBOpen);
const isDel = await UtilsSQLite.isSqlDeleted(this.mDb, this._isDBOpen);
if (isLastMod && isDel) {
const date = Math.round(new Date().getTime() / 1000);
let stmts = `
CREATE TABLE IF NOT EXISTS sync_table (

@@ -478,152 +478,152 @@ id INTEGER PRIMARY KEY NOT NULL,

);`;
stmts += `INSERT INTO sync_table (sync_date) VALUES (
stmts += `INSERT INTO sync_table (sync_date) VALUES (
"${date}");`;
changes = await UtilsSQLite.execute(this.mDb, stmts, false);
return Promise.resolve(changes);
changes = await UtilsSQLite.execute(this.mDb, stmts, false);
return Promise.resolve(changes);
}
else {
return Promise.reject(new Error('No last_modified/sql_deleted columns in tables'));
}
}
else {
return Promise.resolve(0);
}
}
else {
return Promise.reject(new Error('No last_modified/sql_deleted columns in tables'));
catch (err) {
const msg = `CreateSyncTable: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
else {
return Promise.resolve(0);
}
}
catch (err) {
const msg = `CreateSyncTable: ${err.message}`;
return Promise.reject(new Error(msg));
async getSyncDate() {
if (!this._isDBOpen) {
let msg = `getSyncDate: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
const isTable = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('No sync_table available'));
}
const res = await UtilsExportJSON.getSynchroDate(this.mDb);
return Promise.resolve(res);
}
catch (err) {
const msg = `getSyncDate: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
}
async getSyncDate() {
if (!this._isDBOpen) {
let msg = `getSyncDate: Database ${this.dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
async setSyncDate(syncDate) {
if (!this._isDBOpen) {
let msg = `SetSyncDate: Database ${this.dbName} `;
msg += `not opened`;
return { result: false, message: msg };
}
try {
const isTable = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('No sync_table available'));
}
const sDate = Math.round(new Date(syncDate).getTime() / 1000);
let stmt = `UPDATE sync_table SET sync_date = `;
stmt += `${sDate} WHERE id = 1;`;
const changes = await UtilsSQLite.execute(this.mDb, stmt, false);
if (changes < 0) {
return { result: false, message: 'setSyncDate failed' };
}
else {
return { result: true };
}
}
catch (err) {
return { result: false, message: `setSyncDate failed: ${err.message}` };
}
}
try {
const isTable = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('No sync_table available'));
}
const res = await UtilsExportJSON.getSynchroDate(this.mDb);
return Promise.resolve(res);
}
catch (err) {
const msg = `getSyncDate: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
async setSyncDate(syncDate) {
if (!this._isDBOpen) {
let msg = `SetSyncDate: Database ${this.dbName} `;
msg += `not opened`;
return { result: false, message: msg };
}
try {
const isTable = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('No sync_table available'));
}
const sDate = Math.round(new Date(syncDate).getTime() / 1000);
let stmt = `UPDATE sync_table SET sync_date = `;
stmt += `${sDate} WHERE id = 1;`;
const changes = await UtilsSQLite.execute(this.mDb, stmt, false);
if (changes < 0) {
return { result: false, message: 'setSyncDate failed' };
}
else {
return { result: true };
}
}
catch (err) {
return { result: false, message: `setSyncDate failed: ${err.message}` };
}
}
async importJson(jsonData, importProgress) {
let changes = 0;
if (this._isDBOpen) {
try {
// set Foreign Keys Off
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, false);
if (jsonData.tables && jsonData.tables.length > 0) {
// create the database schema
changes = await UtilsImportJSON.createDatabaseSchema(this, jsonData);
let msg = `Schema creation completed changes: ${changes}`;
importProgress.emit({ progress: msg });
if (changes != -1) {
// create the tables data
changes += await UtilsImportJSON.createTablesData(this, jsonData, importProgress);
let msg = `Tables data creation completed changes: ${changes}`;
importProgress.emit({ progress: msg });
}
async importJson(jsonData, importProgress) {
let changes = 0;
if (this._isDBOpen) {
try {
// set Foreign Keys Off
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, false);
if (jsonData.tables && jsonData.tables.length > 0) {
// create the database schema
changes = await UtilsImportJSON.createDatabaseSchema(this, jsonData);
let msg = `Schema creation completed changes: ${changes}`;
importProgress.emit({ progress: msg });
if (changes != -1) {
// create the tables data
changes += await UtilsImportJSON.createTablesData(this, jsonData, importProgress);
let msg = `Tables data creation completed changes: ${changes}`;
importProgress.emit({ progress: msg });
}
}
if (jsonData.views && jsonData.views.length > 0) {
// create the views
changes += await UtilsImportJSON.createViews(this, jsonData);
}
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, true);
await this.saveToStore();
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error(`ImportJson: ${err.message}`));
}
}
if (jsonData.views && jsonData.views.length > 0) {
// create the views
changes += await UtilsImportJSON.createViews(this, jsonData);
else {
return Promise.reject(new Error(`ImportJson: database is closed`));
}
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(this.mDb, true);
await this.saveToStore();
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error(`ImportJson: ${err.message}`));
}
}
else {
return Promise.reject(new Error(`ImportJson: database is closed`));
}
}
async exportJson(mode, exportProgress) {
const inJson = {};
inJson.database = this.dbName.slice(0, -9);
inJson.version = this.version;
inJson.encrypted = false;
inJson.mode = mode;
if (this._isDBOpen) {
try {
const isTable = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (isTable) {
await UtilsExportJSON
.setLastExportDate(this.mDb, (new Date()).toISOString());
async exportJson(mode, exportProgress) {
const inJson = {};
inJson.database = this.dbName.slice(0, -9);
inJson.version = this.version;
inJson.encrypted = false;
inJson.mode = mode;
if (this._isDBOpen) {
try {
const isTable = await UtilsSQLite.isTableExists(this.mDb, 'sync_table');
if (isTable) {
await UtilsExportJSON
.setLastExportDate(this.mDb, (new Date()).toISOString());
}
const retJson = await UtilsExportJSON
.createExportObject(this.mDb, inJson, exportProgress);
const keys = Object.keys(retJson);
if (keys.length === 0) {
const msg = `ExportJson: return Object is empty ` +
`No data to synchronize`;
return Promise.reject(new Error(msg));
}
const isValid = UtilsJSON.isJsonSQLite(retJson);
if (isValid) {
return Promise.resolve(retJson);
}
else {
return Promise.reject(new Error(`ExportJson: retJson not valid`));
}
}
catch (err) {
return Promise.reject(new Error(`ExportJson: ${err.message}`));
}
}
const retJson = await UtilsExportJSON
.createExportObject(this.mDb, inJson, exportProgress);
const keys = Object.keys(retJson);
if (keys.length === 0) {
const msg = `ExportJson: return Object is empty ` +
`No data to synchronize`;
return Promise.reject(new Error(msg));
else {
return Promise.reject(new Error(`ExportJson: database is closed`));
}
const isValid = UtilsJSON.isJsonSQLite(retJson);
if (isValid) {
return Promise.resolve(retJson);
}
async deleteExportedRows() {
if (this._isDBOpen) {
try {
await UtilsExportJSON.delExportedRows(this.mDb);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`deleteExportedRows: ${err.message}`));
}
}
else {
return Promise.reject(new Error(`ExportJson: retJson not valid`));
return Promise.reject(new Error(`deleteExportedRows: database is closed`));
}
}
catch (err) {
return Promise.reject(new Error(`ExportJson: ${err.message}`));
}
}
else {
return Promise.reject(new Error(`ExportJson: database is closed`));
}
}
async deleteExportedRows() {
if (this._isDBOpen) {
try {
await UtilsExportJSON.delExportedRows(this.mDb);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`deleteExportedRows: ${err.message}`));
}
}
else {
return Promise.reject(new Error(`deleteExportedRows: database is closed`));
}
}
}
//# sourceMappingURL=database.js.map

604

dist/collection/utils/utils-delete.js
import { UtilsSQLite } from "./utils-sqlite";
import { UtilsSQLStatement } from "./utils-sqlstatement";
class UtilsDeleteError {
static findReferencesAndUpdate(message) {
return new UtilsDeleteError(message);
}
static getRefs(message) {
return new UtilsDeleteError(message);
}
static getReferences(message) {
return new UtilsDeleteError(message);
}
static searchForRelatedItems(message) {
return new UtilsDeleteError(message);
}
static upDateWhereForDefault(message) {
return new UtilsDeleteError(message);
}
static upDateWhereForRestrict(message) {
return new UtilsDeleteError(message);
}
static upDateWhereForCascade(message) {
return new UtilsDeleteError(message);
}
static executeUpdateForDelete(message) {
return new UtilsDeleteError(message);
}
constructor(message) {
this.message = message;
}
}
export class UtilsDelete {
static async findReferencesAndUpdate(mDB, tableName, whereStmt, initColNames, values) {
try {
let retBool = true;
const result = await UtilsDelete.getReferences(mDB, tableName);
const references = result.retRefs;
const tableNameWithRefs = result.tableWithRefs;
if (references.length <= 0) {
return retBool;
}
if (tableName === tableNameWithRefs) {
return retBool;
}
// Loop through references
for (const ref of references) {
// Extract the FOREIGN KEY constraint info from the ref statement
const foreignKeyInfo = UtilsSQLStatement.extractForeignKeyInfo(ref);
// Get the tableName of the references
const refTable = foreignKeyInfo.tableName;
if (refTable === '' || refTable !== tableName) {
continue;
}
// Get the with ref column names
const withRefsNames = foreignKeyInfo.forKeys;
// Get the column names
const colNames = foreignKeyInfo.refKeys;
if (colNames.length !== withRefsNames.length) {
const msg = "findReferencesAndUpdate: mismatch length";
throw UtilsDeleteError.findReferencesAndUpdate(msg);
}
const action = foreignKeyInfo.action;
if (action === 'NO_ACTION') {
continue;
}
let updTableName = tableNameWithRefs;
let updColNames = withRefsNames;
let results = {
uWhereStmt: '',
setStmt: '',
};
if (!UtilsDelete.checkValuesMatch(withRefsNames, initColNames)) {
// Case: no match
// Search for related items in tableName
const result = await UtilsDelete
.searchForRelatedItems(mDB, updTableName, tableName, whereStmt, withRefsNames, colNames, values);
if (result.relatedItems.length === 0 && result.key.length <= 0) {
continue;
}
if (updTableName !== tableName) {
switch (action) {
case 'RESTRICT':
results = await UtilsDelete
.upDateWhereForRestrict(result);
break;
case 'CASCADE':
results = await UtilsDelete
.upDateWhereForCascade(result);
break;
default:
results = await UtilsDelete
.upDateWhereForDefault(withRefsNames, result);
break;
}
}
}
else {
throw UtilsDeleteError.findReferencesAndUpdate('Not implemented. Please transfer your example to the maintener');
}
if (results.setStmt.length > 0 &&
results.uWhereStmt.length > 0) {
UtilsDelete.executeUpdateForDelete(mDB, updTableName, results.uWhereStmt, results.setStmt, updColNames, values);
}
}
return retBool;
static findReferencesAndUpdate(message) {
return new UtilsDeleteError(message);
}
catch (error) {
const msg = error.message ? error.message : error;
if (error instanceof UtilsDeleteError) {
throw UtilsDeleteError.findReferencesAndUpdate(msg);
}
else {
throw error;
}
static getRefs(message) {
return new UtilsDeleteError(message);
}
}
static async getReferences(db, tableName) {
const sqlStmt = "SELECT sql FROM sqlite_master " +
"WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
"sql LIKE('%" + tableName + "%') AND sql LIKE('%ON DELETE%');";
try {
const res = await UtilsSQLite.queryAll(db, sqlStmt, []);
// get the reference's string(s)
let retRefs = [];
let tableWithRefs = "";
if (res.length > 0) {
let result = UtilsDelete.getRefs(res[0].sql);
retRefs = result.foreignKeys;
tableWithRefs = result.tableName;
}
return Promise.resolve({ tableWithRefs: tableWithRefs, retRefs: retRefs });
static getReferences(message) {
return new UtilsDeleteError(message);
}
catch (err) {
const error = err.message ? err.message : err;
const msg = `getReferences: ${error}`;
throw UtilsDeleteError.getReferences(msg);
static searchForRelatedItems(message) {
return new UtilsDeleteError(message);
}
}
static getRefs(sqlStatement) {
let tableName = '';
const foreignKeys = [];
const statement = UtilsSQLStatement.flattenMultilineString(sqlStatement);
try {
// Regular expression pattern to match the table name
const tableNamePattern = /CREATE\s+TABLE\s+(\w+)\s+\(/;
const tableNameMatch = statement.match(tableNamePattern);
if (tableNameMatch) {
tableName = tableNameMatch[1];
}
// Regular expression pattern to match the FOREIGN KEY constraints
const foreignKeyPattern = /FOREIGN\s+KEY\s+\([^)]+\)\s+REFERENCES\s+(\w+)\s*\([^)]+\)\s+ON\s+DELETE\s+(CASCADE|RESTRICT|SET\s+DEFAULT|SET\s+NULL|NO\s+ACTION)/g;
const foreignKeyMatches = statement.matchAll(foreignKeyPattern);
for (const foreignKeyMatch of foreignKeyMatches) {
const foreignKey = foreignKeyMatch[0];
foreignKeys.push(foreignKey);
}
static upDateWhereForDefault(message) {
return new UtilsDeleteError(message);
}
catch (error) {
const msg = `getRefs: Error creating regular expression: ${error}`;
throw UtilsDeleteError.getRefs(msg);
static upDateWhereForRestrict(message) {
return new UtilsDeleteError(message);
}
return { tableName, foreignKeys };
}
static async getReferencedTableName(refValue) {
var tableName = '';
if (refValue.length > 0) {
const arr = refValue.split(new RegExp('REFERENCES', 'i'));
if (arr.length === 2) {
const oPar = arr[1].indexOf("(");
tableName = arr[1].substring(0, oPar).trim();
}
static upDateWhereForCascade(message) {
return new UtilsDeleteError(message);
}
return tableName;
}
static async searchForRelatedItems(mDB, updTableName, tableName, whStmt, withRefsNames, colNames, values) {
const relatedItems = [];
let key = "";
const t1Names = withRefsNames.map((name) => `t1.${name}`);
const t2Names = colNames.map((name) => `t2.${name}`);
try {
// addPrefix to the whereClause and swap colNames with withRefsNames
let whereClause = UtilsSQLStatement
.addPrefixToWhereClause(whStmt, colNames, withRefsNames, "t2.");
// look at the whereclause and change colNames with withRefsNames
if (whereClause.endsWith(";")) {
whereClause = whereClause.slice(0, -1);
}
const resultString = t1Names
.map((t1, index) => `${t1} = ${t2Names[index]}`)
.join(" AND ");
const sql = `SELECT t1.rowid FROM ${updTableName} t1 ` +
`JOIN ${tableName} t2 ON ${resultString} ` +
`WHERE ${whereClause} AND t1.sql_deleted = 0;`;
const vals = await UtilsSQLite.queryAll(mDB, sql, values);
if (vals.length > 0) {
key = (Object.keys(vals[0]))[0];
relatedItems.push(...vals);
}
return { key: key, relatedItems: relatedItems };
static executeUpdateForDelete(message) {
return new UtilsDeleteError(message);
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.searchForRelatedItems(msg);
constructor(message) {
this.message = message;
}
}
static async upDateWhereForDefault(withRefsNames, results) {
let setStmt = '';
let uWhereStmt = '';
try {
const key = results.key;
const cols = [];
for (const relItem of results.relatedItems) {
const mVal = relItem[key];
if (mVal !== undefined) {
cols.push(mVal);
}
export class UtilsDelete {
static async findReferencesAndUpdate(mDB, tableName, whereStmt, initColNames, values) {
try {
let retBool = true;
const result = await UtilsDelete.getReferences(mDB, tableName);
const references = result.retRefs;
const tableNameWithRefs = result.tableWithRefs;
if (references.length <= 0) {
return retBool;
}
if (tableName === tableNameWithRefs) {
return retBool;
}
// Loop through references
for (const ref of references) {
// Extract the FOREIGN KEY constraint info from the ref statement
const foreignKeyInfo = UtilsSQLStatement.extractForeignKeyInfo(ref);
// Get the tableName of the references
const refTable = foreignKeyInfo.tableName;
if (refTable === '' || refTable !== tableName) {
continue;
}
// Get the with ref column names
const withRefsNames = foreignKeyInfo.forKeys;
// Get the column names
const colNames = foreignKeyInfo.refKeys;
if (colNames.length !== withRefsNames.length) {
const msg = "findReferencesAndUpdate: mismatch length";
throw UtilsDeleteError.findReferencesAndUpdate(msg);
}
const action = foreignKeyInfo.action;
if (action === 'NO_ACTION') {
continue;
}
let updTableName = tableNameWithRefs;
let updColNames = withRefsNames;
let results = {
uWhereStmt: '',
setStmt: '',
};
if (!UtilsDelete.checkValuesMatch(withRefsNames, initColNames)) {
// Case: no match
// Search for related items in tableName
const result = await UtilsDelete
.searchForRelatedItems(mDB, updTableName, tableName, whereStmt, withRefsNames, colNames, values);
if (result.relatedItems.length === 0 && result.key.length <= 0) {
continue;
}
if (updTableName !== tableName) {
switch (action) {
case 'RESTRICT':
results = await UtilsDelete
.upDateWhereForRestrict(result);
break;
case 'CASCADE':
results = await UtilsDelete
.upDateWhereForCascade(result);
break;
default:
results = await UtilsDelete
.upDateWhereForDefault(withRefsNames, result);
break;
}
}
}
else {
throw UtilsDeleteError.findReferencesAndUpdate('Not implemented. Please transfer your example to the maintener');
}
if (results.setStmt.length > 0 &&
results.uWhereStmt.length > 0) {
UtilsDelete.executeUpdateForDelete(mDB, updTableName, results.uWhereStmt, results.setStmt, updColNames, values);
}
}
return retBool;
}
}
// Create the set statement
for (const name of withRefsNames) {
setStmt += `${name} = NULL, `;
}
setStmt += 'sql_deleted = 0';
// const curTime = UtilsDelete.getCurrentTimeAsInteger() + 5;
// setStmt += `last_modified = ${curTime}`;
// Create the where statement
uWhereStmt = `WHERE ${key} IN (`;
for (const col of cols) {
uWhereStmt += `${col},`;
}
if (uWhereStmt.endsWith(',')) {
uWhereStmt = uWhereStmt.slice(0, -1);
}
uWhereStmt += ');';
catch (error) {
const msg = error.message ? error.message : error;
if (error instanceof UtilsDeleteError) {
throw UtilsDeleteError.findReferencesAndUpdate(msg);
}
else {
throw error;
}
}
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.upDateWhereForDefault(msg);
static async getReferences(db, tableName) {
const sqlStmt = "SELECT sql FROM sqlite_master " +
"WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
"sql LIKE('%" + tableName + "%') AND sql LIKE('%ON DELETE%');";
try {
const res = await UtilsSQLite.queryAll(db, sqlStmt, []);
// get the reference's string(s)
let retRefs = [];
let tableWithRefs = "";
if (res.length > 0) {
let result = UtilsDelete.getRefs(res[0].sql);
retRefs = result.foreignKeys;
tableWithRefs = result.tableName;
}
return Promise.resolve({ tableWithRefs: tableWithRefs, retRefs: retRefs });
}
catch (err) {
const error = err.message ? err.message : err;
const msg = `getReferences: ${error}`;
throw UtilsDeleteError.getReferences(msg);
}
}
return { setStmt, uWhereStmt };
}
static async upDateWhereForRestrict(results) {
try {
const setStmt = '';
const uWhereStmt = '';
if (results.relatedItems.length > 0) {
const msg = 'Restrict mode related items exist, please delete them first';
throw UtilsDeleteError.upDateWhereForRestrict(msg);
}
return { setStmt, uWhereStmt };
static getRefs(sqlStatement) {
let tableName = '';
const foreignKeys = [];
const statement = UtilsSQLStatement.flattenMultilineString(sqlStatement);
try {
// Regular expression pattern to match the table name
const tableNamePattern = /CREATE\s+TABLE\s+(\w+)\s+\(/;
const tableNameMatch = statement.match(tableNamePattern);
if (tableNameMatch) {
tableName = tableNameMatch[1];
}
// Regular expression pattern to match the FOREIGN KEY constraints
const foreignKeyPattern = /FOREIGN\s+KEY\s+\([^)]+\)\s+REFERENCES\s+(\w+)\s*\([^)]+\)\s+ON\s+DELETE\s+(CASCADE|RESTRICT|SET\s+DEFAULT|SET\s+NULL|NO\s+ACTION)/g;
const foreignKeyMatches = statement.matchAll(foreignKeyPattern);
for (const foreignKeyMatch of foreignKeyMatches) {
const foreignKey = foreignKeyMatch[0];
foreignKeys.push(foreignKey);
}
}
catch (error) {
const msg = `getRefs: Error creating regular expression: ${error}`;
throw UtilsDeleteError.getRefs(msg);
}
return { tableName, foreignKeys };
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.upDateWhereForRestrict(msg);
static async getReferencedTableName(refValue) {
var tableName = '';
if (refValue.length > 0) {
const arr = refValue.split(new RegExp('REFERENCES', 'i'));
if (arr.length === 2) {
const oPar = arr[1].indexOf("(");
tableName = arr[1].substring(0, oPar).trim();
}
}
return tableName;
}
}
static async upDateWhereForCascade(results) {
let setStmt = '';
let uWhereStmt = '';
try {
const key = results.key;
const cols = [];
for (const relItem of results.relatedItems) {
const mVal = relItem[key];
if (mVal !== undefined) {
cols.push(mVal);
static async searchForRelatedItems(mDB, updTableName, tableName, whStmt, withRefsNames, colNames, values) {
const relatedItems = [];
let key = "";
const t1Names = withRefsNames.map((name) => `t1.${name}`);
const t2Names = colNames.map((name) => `t2.${name}`);
try {
// addPrefix to the whereClause and swap colNames with withRefsNames
let whereClause = UtilsSQLStatement
.addPrefixToWhereClause(whStmt, colNames, withRefsNames, "t2.");
// look at the whereclause and change colNames with withRefsNames
if (whereClause.endsWith(";")) {
whereClause = whereClause.slice(0, -1);
}
const resultString = t1Names
.map((t1, index) => `${t1} = ${t2Names[index]}`)
.join(" AND ");
const sql = `SELECT t1.rowid FROM ${updTableName} t1 ` +
`JOIN ${tableName} t2 ON ${resultString} ` +
`WHERE ${whereClause} AND t1.sql_deleted = 0;`;
const vals = await UtilsSQLite.queryAll(mDB, sql, values);
if (vals.length > 0) {
key = (Object.keys(vals[0]))[0];
relatedItems.push(...vals);
}
return { key: key, relatedItems: relatedItems };
}
}
setStmt += 'sql_deleted = 1';
// Create the where statement
uWhereStmt = `WHERE ${key} IN (`;
for (const col of cols) {
uWhereStmt += `${col},`;
}
if (uWhereStmt.endsWith(',')) {
uWhereStmt = uWhereStmt.slice(0, -1);
}
uWhereStmt += ');';
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.searchForRelatedItems(msg);
}
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.upDateWhereForCascade(msg);
static async upDateWhereForDefault(withRefsNames, results) {
let setStmt = '';
let uWhereStmt = '';
try {
const key = results.key;
const cols = [];
for (const relItem of results.relatedItems) {
const mVal = relItem[key];
if (mVal !== undefined) {
cols.push(mVal);
}
}
// Create the set statement
for (const name of withRefsNames) {
setStmt += `${name} = NULL, `;
}
setStmt += 'sql_deleted = 0';
// const curTime = UtilsDelete.getCurrentTimeAsInteger() + 5;
// setStmt += `last_modified = ${curTime}`;
// Create the where statement
uWhereStmt = `WHERE ${key} IN (`;
for (const col of cols) {
uWhereStmt += `${col},`;
}
if (uWhereStmt.endsWith(',')) {
uWhereStmt = uWhereStmt.slice(0, -1);
}
uWhereStmt += ');';
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.upDateWhereForDefault(msg);
}
return { setStmt, uWhereStmt };
}
return { setStmt, uWhereStmt };
}
static executeUpdateForDelete(mDB, tableName, whereStmt, setStmt, colNames, values) {
try {
let lastId = -1;
// Update sql_deleted for this references
const stmt = `UPDATE ${tableName} SET ${setStmt} ${whereStmt}`;
const selValues = [];
if (values.length > 0) {
const arrVal = whereStmt.split('?');
if (arrVal[arrVal.length - 1] === ';') {
arrVal.pop();
static async upDateWhereForRestrict(results) {
try {
const setStmt = '';
const uWhereStmt = '';
if (results.relatedItems.length > 0) {
const msg = 'Restrict mode related items exist, please delete them first';
throw UtilsDeleteError.upDateWhereForRestrict(msg);
}
return { setStmt, uWhereStmt };
}
for (let jdx = 0; jdx < arrVal.length; jdx++) {
for (const updVal of colNames) {
const indices = UtilsSQLStatement.indicesOf(arrVal[jdx], updVal);
if (indices.length > 0) {
selValues.push(values[jdx]);
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.upDateWhereForRestrict(msg);
}
}
static async upDateWhereForCascade(results) {
let setStmt = '';
let uWhereStmt = '';
try {
const key = results.key;
const cols = [];
for (const relItem of results.relatedItems) {
const mVal = relItem[key];
if (mVal !== undefined) {
cols.push(mVal);
}
}
}
setStmt += 'sql_deleted = 1';
// Create the where statement
uWhereStmt = `WHERE ${key} IN (`;
for (const col of cols) {
uWhereStmt += `${col},`;
}
if (uWhereStmt.endsWith(',')) {
uWhereStmt = uWhereStmt.slice(0, -1);
}
uWhereStmt += ');';
}
}
const retObj = UtilsSQLite.run(mDB, stmt, selValues, false, 'no');
lastId = retObj["lastId"];
if (lastId === -1) {
const msg = `UPDATE sql_deleted failed for table: ${tableName}`;
throw UtilsDeleteError.executeUpdateForDelete(msg);
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.upDateWhereForCascade(msg);
}
return { setStmt, uWhereStmt };
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.executeUpdateForDelete(msg);
static executeUpdateForDelete(mDB, tableName, whereStmt, setStmt, colNames, values) {
try {
let lastId = -1;
// Update sql_deleted for this references
const stmt = `UPDATE ${tableName} SET ${setStmt} ${whereStmt}`;
const selValues = [];
if (values.length > 0) {
const arrVal = whereStmt.split('?');
if (arrVal[arrVal.length - 1] === ';') {
arrVal.pop();
}
for (let jdx = 0; jdx < arrVal.length; jdx++) {
for (const updVal of colNames) {
const indices = UtilsSQLStatement.indicesOf(arrVal[jdx], updVal);
if (indices.length > 0) {
selValues.push(values[jdx]);
}
}
}
}
const retObj = UtilsSQLite.run(mDB, stmt, selValues, false, 'no');
lastId = retObj["lastId"];
if (lastId === -1) {
const msg = `UPDATE sql_deleted failed for table: ${tableName}`;
throw UtilsDeleteError.executeUpdateForDelete(msg);
}
}
catch (error) {
const msg = error.message ? error.message : error;
throw UtilsDeleteError.executeUpdateForDelete(msg);
}
}
}
static getCurrentTimeAsInteger() {
const currentTime = Math.floor(Date.now() / 1000);
return currentTime;
}
static checkValuesMatch(array1, array2) {
for (const value of array1) {
if (!array2.includes(value)) {
return false;
}
static getCurrentTimeAsInteger() {
const currentTime = Math.floor(Date.now() / 1000);
return currentTime;
}
return true;
}
static checkValuesMatch(array1, array2) {
for (const value of array1) {
if (!array2.includes(value)) {
return false;
}
}
return true;
}
}
//# sourceMappingURL=utils-delete.js.map

218

dist/collection/utils/utils-drop.js
import { UtilsSQLite } from "./utils-sqlite";
export class UtilsDrop {
static async getTablesNames(db) {
let sql = 'SELECT name FROM sqlite_master WHERE ';
sql += "type='table' AND name NOT LIKE 'sync_table' ";
sql += "AND name NOT LIKE '_temp_%' ";
sql += "AND name NOT LIKE 'sqlite_%' ";
sql += "ORDER BY rootpage DESC;";
const retArr = [];
try {
const retQuery = await UtilsSQLite.queryAll(db, sql, []);
for (const query of retQuery) {
retArr.push(query.name);
}
return Promise.resolve(retArr);
static async getTablesNames(db) {
let sql = 'SELECT name FROM sqlite_master WHERE ';
sql += "type='table' AND name NOT LIKE 'sync_table' ";
sql += "AND name NOT LIKE '_temp_%' ";
sql += "AND name NOT LIKE 'sqlite_%' ";
sql += "ORDER BY rootpage DESC;";
const retArr = [];
try {
const retQuery = await UtilsSQLite.queryAll(db, sql, []);
for (const query of retQuery) {
retArr.push(query.name);
}
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`GetTablesNames: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`GetTablesNames: ${err.message}`));
static async getViewsNames(mDb) {
let sql = 'SELECT name FROM sqlite_master WHERE ';
sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
sql += 'ORDER BY rootpage DESC;';
const retArr = [];
try {
const retQuery = await UtilsSQLite.queryAll(mDb, sql, []);
for (const query of retQuery) {
retArr.push(query.name);
}
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`getViewsNames: ${err.message}`));
}
}
}
static async getViewsNames(mDb) {
let sql = 'SELECT name FROM sqlite_master WHERE ';
sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
sql += 'ORDER BY rootpage DESC;';
const retArr = [];
try {
const retQuery = await UtilsSQLite.queryAll(mDb, sql, []);
for (const query of retQuery) {
retArr.push(query.name);
}
return Promise.resolve(retArr);
static async dropElements(db, type) {
let msg = '';
let stmt1 = `AND name NOT LIKE ('sqlite_%')`;
switch (type) {
case 'index':
msg = 'DropIndexes';
break;
case 'trigger':
msg = 'DropTriggers';
break;
case 'table':
msg = 'DropTables';
stmt1 += ` AND name NOT IN ('sync_table')`;
break;
case 'view':
msg = 'DropViews';
break;
default:
return Promise.reject(new Error(`DropElements: ${type} ` + 'not found'));
}
// get the element's names
let stmt = 'SELECT name FROM sqlite_master WHERE ';
stmt += `type = '${type}' ${stmt1};`;
try {
const elements = await UtilsSQLite.queryAll(db, stmt, []);
if (elements.length > 0) {
const upType = type.toUpperCase();
const statements = [];
for (const elem of elements) {
let stmt = `DROP ${upType} IF EXISTS `;
stmt += `${elem.name};`;
statements.push(stmt);
}
for (const stmt of statements) {
const lastId = await UtilsSQLite.run(db, stmt, [], false, 'no');
if (lastId < 0) {
return Promise.reject(new Error(`DropElements: ${msg}: lastId < 0`));
}
}
}
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DropElements: ${msg}: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`getViewsNames: ${err.message}`));
static async dropAll(db) {
try {
// drop tables
await UtilsDrop.dropElements(db, 'table');
// drop indexes
await UtilsDrop.dropElements(db, 'index');
// drop triggers
await UtilsDrop.dropElements(db, 'trigger');
// drop views
await UtilsDrop.dropElements(db, 'view');
// vacuum the database
await UtilsSQLite.run(db, 'VACUUM;', [], false, 'no');
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DropAll: ${err.message}`));
}
}
}
static async dropElements(db, type) {
let msg = '';
let stmt1 = `AND name NOT LIKE ('sqlite_%')`;
switch (type) {
case 'index':
msg = 'DropIndexes';
break;
case 'trigger':
msg = 'DropTriggers';
break;
case 'table':
msg = 'DropTables';
stmt1 += ` AND name NOT IN ('sync_table')`;
break;
case 'view':
msg = 'DropViews';
break;
default:
return Promise.reject(new Error(`DropElements: ${type} ` + 'not found'));
}
// get the element's names
let stmt = 'SELECT name FROM sqlite_master WHERE ';
stmt += `type = '${type}' ${stmt1};`;
try {
const elements = await UtilsSQLite.queryAll(db, stmt, []);
if (elements.length > 0) {
const upType = type.toUpperCase();
static async dropTempTables(db, alterTables) {
const tempTables = Object.keys(alterTables);
const statements = [];
for (const elem of elements) {
let stmt = `DROP ${upType} IF EXISTS `;
stmt += `${elem.name};`;
statements.push(stmt);
for (const tTable of tempTables) {
let stmt = 'DROP TABLE IF EXISTS ';
stmt += `_temp_${tTable};`;
statements.push(stmt);
}
for (const stmt of statements) {
const lastId = await UtilsSQLite.run(db, stmt, [], false, 'no');
if (lastId < 0) {
return Promise.reject(new Error(`DropElements: ${msg}: lastId < 0`));
}
try {
const changes = await UtilsSQLite.execute(db, statements.join('\n'), false);
if (changes < 0) {
return Promise.reject(new Error('DropTempTables: changes < 0'));
}
return Promise.resolve();
}
}
return Promise.resolve();
catch (err) {
return Promise.reject(new Error(`DropTempTables: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`DropElements: ${msg}: ${err.message}`));
}
}
static async dropAll(db) {
try {
// drop tables
await UtilsDrop.dropElements(db, 'table');
// drop indexes
await UtilsDrop.dropElements(db, 'index');
// drop triggers
await UtilsDrop.dropElements(db, 'trigger');
// drop views
await UtilsDrop.dropElements(db, 'view');
// vacuum the database
await UtilsSQLite.run(db, 'VACUUM;', [], false, 'no');
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DropAll: ${err.message}`));
}
}
static async dropTempTables(db, alterTables) {
const tempTables = Object.keys(alterTables);
const statements = [];
for (const tTable of tempTables) {
let stmt = 'DROP TABLE IF EXISTS ';
stmt += `_temp_${tTable};`;
statements.push(stmt);
}
try {
const changes = await UtilsSQLite.execute(db, statements.join('\n'), false);
if (changes < 0) {
return Promise.reject(new Error('DropTempTables: changes < 0'));
}
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DropTempTables: ${err.message}`));
}
}
}
//# sourceMappingURL=utils-drop.js.map

1178

dist/collection/utils/utils-exportJson.js
import { UtilsSQLite } from "./utils-sqlite";
import { UtilsJSON } from "./utils-json";
export class UtilsExportJSON {
static async createExportObject(db, sqlObj, exportProgress) {
const retObj = {};
let tables = [];
let views = [];
let errmsg = '';
try {
// get View's name
views = await UtilsExportJSON.getViewsName(db);
// get Table's name
const resTables = await UtilsExportJSON.getTablesNameSQL(db);
if (resTables.length === 0) {
return Promise.reject(new Error("createExportObject: table's names failed"));
}
else {
const isTable = await UtilsSQLite.isTableExists(db, 'sync_table');
if (!isTable && sqlObj.mode === 'partial') {
return Promise.reject(new Error('No sync_table available'));
static async createExportObject(db, sqlObj, exportProgress) {
const retObj = {};
let tables = [];
let views = [];
let errmsg = '';
try {
// get View's name
views = await UtilsExportJSON.getViewsName(db);
// get Table's name
const resTables = await UtilsExportJSON.getTablesNameSQL(db);
if (resTables.length === 0) {
return Promise.reject(new Error("createExportObject: table's names failed"));
}
else {
const isTable = await UtilsSQLite.isTableExists(db, 'sync_table');
if (!isTable && sqlObj.mode === 'partial') {
return Promise.reject(new Error('No sync_table available'));
}
switch (sqlObj.mode) {
case 'partial': {
tables = await UtilsExportJSON.getTablesPartial(db, resTables, exportProgress);
break;
}
case 'full': {
tables = await UtilsExportJSON.getTablesFull(db, resTables, exportProgress);
break;
}
default: {
errmsg =
'createExportObject: expMode ' + sqlObj.mode + ' not defined';
break;
}
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
if (tables.length > 0) {
retObj.database = sqlObj.database;
retObj.version = sqlObj.version;
retObj.encrypted = sqlObj.encrypted;
retObj.mode = sqlObj.mode;
retObj.tables = tables;
if (views.length > 0) {
retObj.views = views;
}
}
return Promise.resolve(retObj);
}
}
switch (sqlObj.mode) {
case 'partial': {
tables = await UtilsExportJSON.getTablesPartial(db, resTables, exportProgress);
break;
}
case 'full': {
tables = await UtilsExportJSON.getTablesFull(db, resTables, exportProgress);
break;
}
default: {
errmsg =
'createExportObject: expMode ' + sqlObj.mode + ' not defined';
break;
}
catch (err) {
return Promise.reject(new Error('createExportObject: ' + err.message));
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
static async getViewsName(mDb) {
const views = [];
let sql = 'SELECT name,sql FROM sqlite_master WHERE ';
sql += "type='view' AND name NOT LIKE 'sqlite_%';";
let retQuery = [];
try {
retQuery = await UtilsSQLite.queryAll(mDb, sql, []);
for (const query of retQuery) {
const view = {};
view.name = query.name;
view.value = query.sql.substring(query.sql.indexOf('AS ') + 3);
views.push(view);
}
return Promise.resolve(views);
}
if (tables.length > 0) {
retObj.database = sqlObj.database;
retObj.version = sqlObj.version;
retObj.encrypted = sqlObj.encrypted;
retObj.mode = sqlObj.mode;
retObj.tables = tables;
if (views.length > 0) {
retObj.views = views;
}
catch (err) {
return Promise.reject(new Error(`getViewsName: ${err.message}`));
}
return Promise.resolve(retObj);
}
}
catch (err) {
return Promise.reject(new Error('createExportObject: ' + err.message));
static async getTablesFull(db, resTables, exportProgress) {
const tables = [];
let errmsg = '';
try {
// Loop through the tables
for (const rTable of resTables) {
let tableName;
let sqlStmt;
if (rTable.name) {
tableName = rTable.name;
}
else {
errmsg = 'GetTablesFull: no name';
break;
}
if (rTable.sql) {
sqlStmt = rTable.sql;
}
else {
errmsg = 'GetTablesFull: no sql';
break;
}
const table = {};
// create Table's Schema
const schema = await UtilsExportJSON.getSchema(sqlStmt /*, tableName*/);
if (schema.length === 0) {
errmsg = 'GetTablesFull: no Schema returned';
break;
}
// check schema validity
await UtilsJSON.checkSchemaValidity(schema);
// create Table's indexes if any
const indexes = await UtilsExportJSON.getIndexes(db, tableName);
if (indexes.length > 0) {
// check indexes validity
await UtilsJSON.checkIndexesValidity(indexes);
}
// create Table's triggers if any
const triggers = await UtilsExportJSON.getTriggers(db, tableName);
if (triggers.length > 0) {
// check triggers validity
await UtilsJSON.checkTriggersValidity(triggers);
}
let msg = `Full: Table ${tableName} schema export completed ...`;
exportProgress.emit({ progress: msg });
// create Table's Data
const query = `SELECT * FROM ${tableName};`;
const values = await UtilsJSON.getValues(db, query, tableName);
table.name = tableName;
if (schema.length > 0) {
table.schema = schema;
}
else {
errmsg = `GetTablesFull: must contain schema`;
break;
}
if (indexes.length > 0) {
table.indexes = indexes;
}
if (triggers.length > 0) {
table.triggers = triggers;
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesFull: table ${tableName} is not a jsonTable`;
break;
}
msg = `Full: Table ${tableName} table data export completed ...`;
exportProgress.emit({ progress: msg });
tables.push(table);
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(tables);
}
catch (err) {
return Promise.reject(new Error(`GetTablesFull: ${err.message}`));
}
}
}
static async getViewsName(mDb) {
const views = [];
let sql = 'SELECT name,sql FROM sqlite_master WHERE ';
sql += "type='view' AND name NOT LIKE 'sqlite_%';";
let retQuery = [];
try {
retQuery = await UtilsSQLite.queryAll(mDb, sql, []);
for (const query of retQuery) {
const view = {};
view.name = query.name;
view.value = query.sql.substring(query.sql.indexOf('AS ') + 3);
views.push(view);
}
return Promise.resolve(views);
}
catch (err) {
return Promise.reject(new Error(`getViewsName: ${err.message}`));
}
}
static async getTablesFull(db, resTables, exportProgress) {
const tables = [];
let errmsg = '';
try {
// Loop through the tables
for (const rTable of resTables) {
let tableName;
let sqlStmt;
if (rTable.name) {
tableName = rTable.name;
static async getSchema(sqlStmt /*, tableName: string*/) {
const schema = [];
// take the substring between parenthesis
const openPar = sqlStmt.indexOf('(');
const closePar = sqlStmt.lastIndexOf(')');
let sstr = sqlStmt.substring(openPar + 1, closePar);
// check if there is other parenthesis and replace the ',' by '§'
try {
sstr = await UtilsExportJSON.modEmbeddedParentheses(sstr);
const sch = sstr.split(",");
// for each element of the array split the
// first word as key
for (let j = 0; j < sch.length; j++) {
let row = [];
const scht = sch[j].replace(/\n/g, "").trim();
row[0] = scht.substring(0, scht.indexOf(" "));
row[1] = scht.substring(scht.indexOf(" ") + 1);
const jsonRow = {};
if (row[0].toUpperCase() === "FOREIGN") {
const oPar = scht.indexOf("(");
const cPar = scht.indexOf(")");
const fk = scht.substring(oPar + 1, cPar);
const fknames = fk.split('§');
row[0] = fknames.join(',');
row[0] = row[0].replace(/, /g, ",");
row[1] = scht.substring(cPar + 2);
jsonRow['foreignkey'] = row[0];
}
else if (row[0].toUpperCase() === "PRIMARY") {
const oPar = scht.indexOf("(");
const cPar = scht.indexOf(")");
const pk = scht.substring(oPar + 1, cPar);
const pknames = pk.split('§');
row[0] = "CPK_" + pknames.join('_');
row[0] = row[0].replace(/_ /g, "_");
row[1] = scht;
jsonRow['constraint'] = row[0];
}
else if (row[0].toUpperCase() === "CONSTRAINT") {
let tRow = [];
const row1t = row[1].trim();
tRow[0] = row1t.substring(0, row1t.indexOf(" "));
tRow[1] = row1t.substring(row1t.indexOf(" ") + 1);
row[0] = tRow[0];
jsonRow['constraint'] = row[0];
row[1] = tRow[1];
}
else {
jsonRow['column'] = row[0];
}
jsonRow['value'] = row[1].replace(/§/g, ",");
schema.push(jsonRow);
}
return Promise.resolve(schema);
}
else {
errmsg = 'GetTablesFull: no name';
break;
catch (err) {
return Promise.reject(new Error(err.message));
}
if (rTable.sql) {
sqlStmt = rTable.sql;
}
static async getIndexes(db, tableName) {
const indexes = [];
let errmsg = '';
try {
let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
stmt += `type = 'index' AND tbl_name = '${tableName}' `;
stmt += `AND sql NOTNULL;`;
const retIndexes = await UtilsSQLite.queryAll(db, stmt, []);
if (retIndexes.length > 0) {
for (const rIndex of retIndexes) {
const keys = Object.keys(rIndex);
if (keys.length === 3) {
if (rIndex['tbl_name'] === tableName) {
const sql = rIndex['sql'];
const mode = sql.includes('UNIQUE') ? 'UNIQUE' : '';
const oPar = sql.lastIndexOf('(');
const cPar = sql.lastIndexOf(')');
const index = {};
index.name = rIndex['name'];
index.value = sql.slice(oPar + 1, cPar);
if (mode.length > 0)
index.mode = mode;
indexes.push(index);
}
else {
errmsg = `GetIndexes: Table ${tableName} doesn't match`;
break;
}
}
else {
errmsg = `GetIndexes: Table ${tableName} creating indexes`;
break;
}
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
}
return Promise.resolve(indexes);
}
else {
errmsg = 'GetTablesFull: no sql';
break;
catch (err) {
return Promise.reject(new Error(`GetIndexes: ${err.message}`));
}
const table = {};
// create Table's Schema
const schema = await UtilsExportJSON.getSchema(sqlStmt /*, tableName*/);
if (schema.length === 0) {
errmsg = 'GetTablesFull: no Schema returned';
break;
}
static async getTriggers(db, tableName) {
const triggers = [];
try {
let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
stmt += `type = 'trigger' AND tbl_name = '${tableName}' `;
stmt += `AND sql NOT NULL;`;
const retTriggers = await UtilsSQLite.queryAll(db, stmt, []);
if (retTriggers.length > 0) {
for (const rTrg of retTriggers) {
const keys = Object.keys(rTrg);
if (keys.length === 3) {
if (rTrg['tbl_name'] === tableName) {
const sql = rTrg['sql'];
const name = rTrg['name'];
let sqlArr = sql.split(name);
if (sqlArr.length != 2) {
return Promise.reject(new Error(`GetTriggers: sql split name does not return 2 values`));
}
if (!sqlArr[1].includes(tableName)) {
return Promise.reject(new Error(`GetTriggers: sql split does not contains ${tableName}`));
}
const timeEvent = sqlArr[1].split(tableName, 1)[0].trim();
sqlArr = sqlArr[1].split(timeEvent + ' ' + tableName);
if (sqlArr.length != 2) {
return Promise.reject(new Error(`GetTriggers: sql split tableName does not return 2 values`));
}
let condition = '';
let logic = '';
if (sqlArr[1].trim().substring(0, 5).toUpperCase() !== 'BEGIN') {
sqlArr = sqlArr[1].trim().split('BEGIN');
if (sqlArr.length != 2) {
return Promise.reject(new Error(`GetTriggers: sql split BEGIN does not return 2 values`));
}
condition = sqlArr[0].trim();
logic = 'BEGIN' + sqlArr[1];
}
else {
logic = sqlArr[1].trim();
}
const trigger = {};
trigger.name = name;
trigger.logic = logic;
if (condition.length > 0)
trigger.condition = condition;
trigger.timeevent = timeEvent;
triggers.push(trigger);
}
else {
return Promise.reject(new Error(`GetTriggers: Table ${tableName} doesn't match`));
}
}
else {
return Promise.reject(new Error(`GetTriggers: Table ${tableName} creating indexes`));
}
}
}
return Promise.resolve(triggers);
}
// check schema validity
await UtilsJSON.checkSchemaValidity(schema);
// create Table's indexes if any
const indexes = await UtilsExportJSON.getIndexes(db, tableName);
if (indexes.length > 0) {
// check indexes validity
await UtilsJSON.checkIndexesValidity(indexes);
catch (err) {
return Promise.reject(new Error(`GetTriggers: ${err.message}`));
}
// create Table's triggers if any
const triggers = await UtilsExportJSON.getTriggers(db, tableName);
if (triggers.length > 0) {
// check triggers validity
await UtilsJSON.checkTriggersValidity(triggers);
}
static async getTablesPartial(db, resTables, exportProgress) {
const tables = [];
let modTables = {};
let syncDate = 0;
let modTablesKeys = [];
let errmsg = '';
try {
// Get the syncDate and the Modified Tables
const partialModeData = await UtilsExportJSON
.getPartialModeData(db, resTables);
if (Object.keys(partialModeData).includes('syncDate')) {
syncDate = partialModeData.syncDate;
}
if (Object.keys(partialModeData).includes('modTables')) {
modTables = partialModeData.modTables;
modTablesKeys = Object.keys(modTables);
}
// Loop trough tables
for (const rTable of resTables) {
let tableName = '';
let sqlStmt = '';
if (rTable.name) {
tableName = rTable.name;
}
else {
errmsg = 'GetTablesFull: no name';
break;
}
if (rTable.sql) {
sqlStmt = rTable.sql;
}
else {
errmsg = 'GetTablesFull: no sql';
break;
}
if (modTablesKeys.length == 0 ||
modTablesKeys.indexOf(tableName) === -1 ||
modTables[tableName] == 'No') {
continue;
}
const table = {};
let schema = [];
let indexes = [];
let triggers = [];
table.name = rTable;
if (modTables[table.name] === 'Create') {
// create Table's Schema
schema = await UtilsExportJSON.getSchema(sqlStmt /*, tableName*/);
if (schema.length > 0) {
// check schema validity
await UtilsJSON.checkSchemaValidity(schema);
}
// create Table's indexes if any
indexes = await UtilsExportJSON.getIndexes(db, tableName);
if (indexes.length > 0) {
// check indexes validity
await UtilsJSON.checkIndexesValidity(indexes);
}
// create Table's triggers if any
triggers = await UtilsExportJSON.getTriggers(db, tableName);
if (triggers.length > 0) {
// check triggers validity
await UtilsJSON.checkTriggersValidity(triggers);
}
}
let msg = `Partial: Table ${tableName} schema export completed ...`;
exportProgress.emit({ progress: msg });
// create Table's Data
let query = '';
if (modTables[tableName] === 'Create') {
query = `SELECT * FROM ${tableName};`;
}
else {
query =
`SELECT * FROM ${tableName} ` +
`WHERE last_modified > ${syncDate};`;
}
const values = await UtilsJSON.getValues(db, query, tableName);
// check the table object validity
table.name = tableName;
if (schema.length > 0) {
table.schema = schema;
}
if (indexes.length > 0) {
table.indexes = indexes;
}
if (triggers.length > 0) {
table.triggers = triggers;
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesPartial: table ${tableName} is not a jsonTable`;
break;
}
msg = `Partial: Table ${tableName} table data export completed ...`;
exportProgress.emit({ progress: msg });
tables.push(table);
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(tables);
}
let msg = `Full: Table ${tableName} schema export completed ...`;
exportProgress.emit({ progress: msg });
// create Table's Data
const query = `SELECT * FROM ${tableName};`;
const values = await UtilsJSON.getValues(db, query, tableName);
table.name = tableName;
if (schema.length > 0) {
table.schema = schema;
catch (err) {
return Promise.reject(new Error(`GetTablesPartial: ${err.message}`));
}
else {
errmsg = `GetTablesFull: must contain schema`;
break;
}
static async getPartialModeData(db, resTables) {
const retData = {};
try {
// get the synchronization date
const syncDate = await UtilsExportJSON.getSynchroDate(db);
if (syncDate <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no syncDate`));
}
// get the tables which have been updated
// since last synchronization
const modTables = await UtilsExportJSON.getTablesModified(db, resTables, syncDate);
if (modTables.length <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no modTables`));
}
retData.syncDate = syncDate;
retData.modTables = modTables;
return Promise.resolve(retData);
}
if (indexes.length > 0) {
table.indexes = indexes;
catch (err) {
return Promise.reject(new Error(`GetPartialModeData: ${err.message}`));
}
if (triggers.length > 0) {
table.triggers = triggers;
}
static async getTablesNameSQL(db) {
let sql = 'SELECT name,sql FROM sqlite_master WHERE ';
sql += "type='table' AND name NOT LIKE 'sync_table' ";
sql += "AND name NOT LIKE '_temp_%' ";
sql += "AND name NOT LIKE 'sqlite_%';";
try {
const retQuery = await UtilsSQLite.queryAll(db, sql, []);
return Promise.resolve(retQuery);
}
if (values.length > 0) {
table.values = values;
catch (err) {
return Promise.reject(new Error(`getTablesNamesSQL: ${err.message}`));
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesFull: table ${tableName} is not a jsonTable`;
break;
}
msg = `Full: Table ${tableName} table data export completed ...`;
exportProgress.emit({ progress: msg });
tables.push(table);
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(tables);
}
catch (err) {
return Promise.reject(new Error(`GetTablesFull: ${err.message}`));
}
}
static async getSchema(sqlStmt /*, tableName: string*/) {
const schema = [];
// take the substring between parenthesis
const openPar = sqlStmt.indexOf('(');
const closePar = sqlStmt.lastIndexOf(')');
let sstr = sqlStmt.substring(openPar + 1, closePar);
// check if there is other parenthesis and replace the ',' by '§'
try {
sstr = await UtilsExportJSON.modEmbeddedParentheses(sstr);
const sch = sstr.split(",");
// for each element of the array split the
// first word as key
for (let j = 0; j < sch.length; j++) {
let row = [];
const scht = sch[j].replace(/\n/g, "").trim();
row[0] = scht.substring(0, scht.indexOf(" "));
row[1] = scht.substring(scht.indexOf(" ") + 1);
const jsonRow = {};
if (row[0].toUpperCase() === "FOREIGN") {
const oPar = scht.indexOf("(");
const cPar = scht.indexOf(")");
const fk = scht.substring(oPar + 1, cPar);
const fknames = fk.split('§');
row[0] = fknames.join(',');
row[0] = row[0].replace(/, /g, ",");
row[1] = scht.substring(cPar + 2);
jsonRow['foreignkey'] = row[0];
static async getTablesModified(db, tables, syncDate) {
let errmsg = '';
try {
const retModified = {};
for (const rTable of tables) {
let mode;
// get total count of the table
let stmt = 'SELECT count(*) AS tcount ';
stmt += `FROM ${rTable.name};`;
let retQuery = await UtilsSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) {
errmsg = 'GetTableModified: total ' + 'count not returned';
break;
}
const totalCount = retQuery[0]['tcount'];
// get total count of modified since last sync
stmt = 'SELECT count(*) AS mcount FROM ';
stmt += `${rTable.name} WHERE last_modified > `;
stmt += `${syncDate};`;
retQuery = await UtilsSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1)
break;
const totalModifiedCount = retQuery[0]['mcount'];
if (totalModifiedCount === 0) {
mode = 'No';
}
else if (totalCount === totalModifiedCount) {
mode = 'Create';
}
else {
mode = 'Modified';
}
const key = rTable.name;
retModified[key] = mode;
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(retModified);
}
else if (row[0].toUpperCase() === "PRIMARY") {
const oPar = scht.indexOf("(");
const cPar = scht.indexOf(")");
const pk = scht.substring(oPar + 1, cPar);
const pknames = pk.split('§');
row[0] = "CPK_" + pknames.join('_');
row[0] = row[0].replace(/_ /g, "_");
row[1] = scht;
jsonRow['constraint'] = row[0];
catch (err) {
return Promise.reject(new Error(`GetTableModified: ${err.message}`));
}
else if (row[0].toUpperCase() === "CONSTRAINT") {
let tRow = [];
const row1t = row[1].trim();
tRow[0] = row1t.substring(0, row1t.indexOf(" "));
tRow[1] = row1t.substring(row1t.indexOf(" ") + 1);
row[0] = tRow[0];
jsonRow['constraint'] = row[0];
row[1] = tRow[1];
}
static async getSynchroDate(db) {
try {
const stmt = `SELECT sync_date FROM sync_table WHERE id = 1;`;
const res = await UtilsSQLite.queryAll(db, stmt, []);
return Promise.resolve(res[0]["sync_date"]);
}
else {
jsonRow['column'] = row[0];
catch (err) {
const msg = `GetSynchroDate: ${err.message}`;
return Promise.reject(new Error(msg));
}
jsonRow['value'] = row[1].replace(/§/g, ",");
schema.push(jsonRow);
}
return Promise.resolve(schema);
}
catch (err) {
return Promise.reject(new Error(err.message));
}
}
static async getIndexes(db, tableName) {
const indexes = [];
let errmsg = '';
try {
let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
stmt += `type = 'index' AND tbl_name = '${tableName}' `;
stmt += `AND sql NOTNULL;`;
const retIndexes = await UtilsSQLite.queryAll(db, stmt, []);
if (retIndexes.length > 0) {
for (const rIndex of retIndexes) {
const keys = Object.keys(rIndex);
if (keys.length === 3) {
if (rIndex['tbl_name'] === tableName) {
const sql = rIndex['sql'];
const mode = sql.includes('UNIQUE') ? 'UNIQUE' : '';
const oPar = sql.lastIndexOf('(');
const cPar = sql.lastIndexOf(')');
const index = {};
index.name = rIndex['name'];
index.value = sql.slice(oPar + 1, cPar);
if (mode.length > 0)
index.mode = mode;
indexes.push(index);
static async getLastExportDate(db) {
try {
const stmt = `SELECT sync_date FROM sync_table WHERE id = 2;`;
const res = await UtilsSQLite.queryAll(db, stmt, []);
if (res.length === 0) {
return Promise.resolve(-1);
}
else {
errmsg = `GetIndexes: Table ${tableName} doesn't match`;
break;
return Promise.resolve(res[0]["sync_date"]);
}
}
else {
errmsg = `GetIndexes: Table ${tableName} creating indexes`;
break;
}
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
catch (err) {
const msg = `getLastExport: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
return Promise.resolve(indexes);
}
catch (err) {
return Promise.reject(new Error(`GetIndexes: ${err.message}`));
}
}
static async getTriggers(db, tableName) {
const triggers = [];
try {
let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
stmt += `type = 'trigger' AND tbl_name = '${tableName}' `;
stmt += `AND sql NOT NULL;`;
const retTriggers = await UtilsSQLite.queryAll(db, stmt, []);
if (retTriggers.length > 0) {
for (const rTrg of retTriggers) {
const keys = Object.keys(rTrg);
if (keys.length === 3) {
if (rTrg['tbl_name'] === tableName) {
const sql = rTrg['sql'];
const name = rTrg['name'];
let sqlArr = sql.split(name);
if (sqlArr.length != 2) {
return Promise.reject(new Error(`GetTriggers: sql split name does not return 2 values`));
}
if (!sqlArr[1].includes(tableName)) {
return Promise.reject(new Error(`GetTriggers: sql split does not contains ${tableName}`));
}
const timeEvent = sqlArr[1].split(tableName, 1)[0].trim();
sqlArr = sqlArr[1].split(timeEvent + ' ' + tableName);
if (sqlArr.length != 2) {
return Promise.reject(new Error(`GetTriggers: sql split tableName does not return 2 values`));
}
let condition = '';
let logic = '';
if (sqlArr[1].trim().substring(0, 5).toUpperCase() !== 'BEGIN') {
sqlArr = sqlArr[1].trim().split('BEGIN');
if (sqlArr.length != 2) {
return Promise.reject(new Error(`GetTriggers: sql split BEGIN does not return 2 values`));
}
condition = sqlArr[0].trim();
logic = 'BEGIN' + sqlArr[1];
}
else {
logic = sqlArr[1].trim();
}
const trigger = {};
trigger.name = name;
trigger.logic = logic;
if (condition.length > 0)
trigger.condition = condition;
trigger.timeevent = timeEvent;
triggers.push(trigger);
static async setLastExportDate(db, lastExportedDate) {
try {
const isTable = await UtilsSQLite.isTableExists(db, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('setLastExportDate: No sync_table available'));
}
const sDate = Math.round(new Date(lastExportedDate).getTime() / 1000);
let stmt = "";
if (await UtilsExportJSON.getLastExportDate(db) > 0) {
stmt = `UPDATE sync_table SET sync_date = ${sDate} WHERE id = 2;`;
}
else {
return Promise.reject(new Error(`GetTriggers: Table ${tableName} doesn't match`));
stmt = `INSERT INTO sync_table (sync_date) VALUES (${sDate});`;
}
}
else {
return Promise.reject(new Error(`GetTriggers: Table ${tableName} creating indexes`));
}
const changes = await UtilsSQLite.execute(db, stmt, false);
if (changes < 0) {
return { result: false, message: 'setLastExportDate failed' };
}
else {
return { result: true };
}
}
}
return Promise.resolve(triggers);
catch (err) {
return { result: false, message: `setLastExportDate failed: ${err.message}` };
}
}
catch (err) {
return Promise.reject(new Error(`GetTriggers: ${err.message}`));
}
}
static async getTablesPartial(db, resTables, exportProgress) {
const tables = [];
let modTables = {};
let syncDate = 0;
let modTablesKeys = [];
let errmsg = '';
try {
// Get the syncDate and the Modified Tables
const partialModeData = await UtilsExportJSON
.getPartialModeData(db, resTables);
if (Object.keys(partialModeData).includes('syncDate')) {
syncDate = partialModeData.syncDate;
}
if (Object.keys(partialModeData).includes('modTables')) {
modTables = partialModeData.modTables;
modTablesKeys = Object.keys(modTables);
}
// Loop trough tables
for (const rTable of resTables) {
let tableName = '';
let sqlStmt = '';
if (rTable.name) {
tableName = rTable.name;
static async delExportedRows(db) {
let lastExportDate;
try {
// check if synchronization table exists
const isTable = await UtilsSQLite.isTableExists(db, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('DelExportedRows: No sync_table available'));
}
// get the last export date
lastExportDate = await UtilsExportJSON.getLastExportDate(db);
if (lastExportDate < 0) {
return Promise.reject(new Error("DelExportedRows: no last exported date available"));
}
// get the table' name list
const resTables = await UtilsSQLite.getTableList(db);
if (resTables.length === 0) {
return Promise.reject(new Error("DelExportedRows: No table's names returned"));
}
// Loop through the tables
for (const table of resTables) {
let lastId = -1;
// define the delete statement
const delStmt = `DELETE FROM ${table}
WHERE sql_deleted = 1 AND last_modified < ${lastExportDate};`;
lastId = await UtilsSQLite.run(db, delStmt, [], true, 'no');
if (lastId < 0) {
return Promise.reject(new Error('DelExportedRows: lastId < 0'));
}
}
}
else {
errmsg = 'GetTablesFull: no name';
break;
catch (err) {
return Promise.reject(new Error(`DelExportedRows failed: ${err.message}`));
}
if (rTable.sql) {
sqlStmt = rTable.sql;
}
else {
errmsg = 'GetTablesFull: no sql';
break;
}
if (modTablesKeys.length == 0 ||
modTablesKeys.indexOf(tableName) === -1 ||
modTables[tableName] == 'No') {
continue;
}
const table = {};
let schema = [];
let indexes = [];
let triggers = [];
table.name = rTable;
if (modTables[table.name] === 'Create') {
// create Table's Schema
schema = await UtilsExportJSON.getSchema(sqlStmt /*, tableName*/);
if (schema.length > 0) {
// check schema validity
await UtilsJSON.checkSchemaValidity(schema);
}
// create Table's indexes if any
indexes = await UtilsExportJSON.getIndexes(db, tableName);
if (indexes.length > 0) {
// check indexes validity
await UtilsJSON.checkIndexesValidity(indexes);
}
// create Table's triggers if any
triggers = await UtilsExportJSON.getTriggers(db, tableName);
if (triggers.length > 0) {
// check triggers validity
await UtilsJSON.checkTriggersValidity(triggers);
}
}
let msg = `Partial: Table ${tableName} schema export completed ...`;
exportProgress.emit({ progress: msg });
// create Table's Data
let query = '';
if (modTables[tableName] === 'Create') {
query = `SELECT * FROM ${tableName};`;
}
else {
query =
`SELECT * FROM ${tableName} ` +
`WHERE last_modified > ${syncDate};`;
}
const values = await UtilsJSON.getValues(db, query, tableName);
// check the table object validity
table.name = tableName;
if (schema.length > 0) {
table.schema = schema;
}
if (indexes.length > 0) {
table.indexes = indexes;
}
if (triggers.length > 0) {
table.triggers = triggers;
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesPartial: table ${tableName} is not a jsonTable`;
break;
}
msg = `Partial: Table ${tableName} table data export completed ...`;
exportProgress.emit({ progress: msg });
tables.push(table);
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(tables);
}
catch (err) {
return Promise.reject(new Error(`GetTablesPartial: ${err.message}`));
}
}
static async getPartialModeData(db, resTables) {
const retData = {};
try {
// get the synchronization date
const syncDate = await UtilsExportJSON.getSynchroDate(db);
if (syncDate <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no syncDate`));
}
// get the tables which have been updated
// since last synchronization
const modTables = await UtilsExportJSON.getTablesModified(db, resTables, syncDate);
if (modTables.length <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no modTables`));
}
retData.syncDate = syncDate;
retData.modTables = modTables;
return Promise.resolve(retData);
}
catch (err) {
return Promise.reject(new Error(`GetPartialModeData: ${err.message}`));
}
}
static async getTablesNameSQL(db) {
let sql = 'SELECT name,sql FROM sqlite_master WHERE ';
sql += "type='table' AND name NOT LIKE 'sync_table' ";
sql += "AND name NOT LIKE '_temp_%' ";
sql += "AND name NOT LIKE 'sqlite_%';";
try {
const retQuery = await UtilsSQLite.queryAll(db, sql, []);
return Promise.resolve(retQuery);
}
catch (err) {
return Promise.reject(new Error(`getTablesNamesSQL: ${err.message}`));
}
}
static async getTablesModified(db, tables, syncDate) {
let errmsg = '';
try {
const retModified = {};
for (const rTable of tables) {
let mode;
// get total count of the table
let stmt = 'SELECT count(*) AS tcount ';
stmt += `FROM ${rTable.name};`;
let retQuery = await UtilsSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) {
errmsg = 'GetTableModified: total ' + 'count not returned';
break;
static async modEmbeddedParentheses(sstr) {
const oParArray = UtilsExportJSON.indexOfChar(sstr, '(');
const cParArray = UtilsExportJSON.indexOfChar(sstr, ')');
if (oParArray.length != cParArray.length) {
return Promise.reject("ModEmbeddedParentheses: Not same number of '(' & ')'");
}
const totalCount = retQuery[0]['tcount'];
// get total count of modified since last sync
stmt = 'SELECT count(*) AS mcount FROM ';
stmt += `${rTable.name} WHERE last_modified > `;
stmt += `${syncDate};`;
retQuery = await UtilsSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1)
break;
const totalModifiedCount = retQuery[0]['mcount'];
if (totalModifiedCount === 0) {
mode = 'No';
if (oParArray.length === 0) {
return Promise.resolve(sstr);
}
else if (totalCount === totalModifiedCount) {
mode = 'Create';
let resStmt = sstr.substring(0, oParArray[0] - 1);
for (let i = 0; i < oParArray.length; i++) {
let str;
if (i < oParArray.length - 1) {
if (oParArray[i + 1] < cParArray[i]) {
str = sstr.substring(oParArray[i] - 1, cParArray[i + 1]);
i++;
}
else {
str = sstr.substring(oParArray[i] - 1, cParArray[i]);
}
}
else {
str = sstr.substring(oParArray[i] - 1, cParArray[i]);
}
const newS = str.replace(/,/g, "§");
resStmt += newS;
if (i < oParArray.length - 1) {
resStmt += sstr.substring(cParArray[i], oParArray[i + 1] - 1);
}
}
else {
mode = 'Modified';
}
const key = rTable.name;
retModified[key] = mode;
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(retModified);
resStmt += sstr.substring(cParArray[cParArray.length - 1], sstr.length);
return Promise.resolve(resStmt);
}
catch (err) {
return Promise.reject(new Error(`GetTableModified: ${err.message}`));
static indexOfChar(str, char) {
let tmpArr = [...str];
char = char.toLowerCase();
return tmpArr.reduce((results, elem, idx) => elem.toLowerCase() === char ? [...results, idx] : results, []);
}
}
static async getSynchroDate(db) {
try {
const stmt = `SELECT sync_date FROM sync_table WHERE id = 1;`;
const res = await UtilsSQLite.queryAll(db, stmt, []);
return Promise.resolve(res[0]["sync_date"]);
}
catch (err) {
const msg = `GetSynchroDate: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
static async getLastExportDate(db) {
try {
const stmt = `SELECT sync_date FROM sync_table WHERE id = 2;`;
const res = await UtilsSQLite.queryAll(db, stmt, []);
if (res.length === 0) {
return Promise.resolve(-1);
}
else {
return Promise.resolve(res[0]["sync_date"]);
}
}
catch (err) {
const msg = `getLastExport: ${err.message}`;
return Promise.reject(new Error(msg));
}
}
static async setLastExportDate(db, lastExportedDate) {
try {
const isTable = await UtilsSQLite.isTableExists(db, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('setLastExportDate: No sync_table available'));
}
const sDate = Math.round(new Date(lastExportedDate).getTime() / 1000);
let stmt = "";
if (await UtilsExportJSON.getLastExportDate(db) > 0) {
stmt = `UPDATE sync_table SET sync_date = ${sDate} WHERE id = 2;`;
}
else {
stmt = `INSERT INTO sync_table (sync_date) VALUES (${sDate});`;
}
const changes = await UtilsSQLite.execute(db, stmt, false);
if (changes < 0) {
return { result: false, message: 'setLastExportDate failed' };
}
else {
return { result: true };
}
}
catch (err) {
return { result: false, message: `setLastExportDate failed: ${err.message}` };
}
}
static async delExportedRows(db) {
let lastExportDate;
try {
// check if synchronization table exists
const isTable = await UtilsSQLite.isTableExists(db, 'sync_table');
if (!isTable) {
return Promise.reject(new Error('DelExportedRows: No sync_table available'));
}
// get the last export date
lastExportDate = await UtilsExportJSON.getLastExportDate(db);
if (lastExportDate < 0) {
return Promise.reject(new Error("DelExportedRows: no last exported date available"));
}
// get the table' name list
const resTables = await UtilsSQLite.getTableList(db);
if (resTables.length === 0) {
return Promise.reject(new Error("DelExportedRows: No table's names returned"));
}
// Loop through the tables
for (const table of resTables) {
let lastId = -1;
// define the delete statement
const delStmt = `DELETE FROM ${table}
WHERE sql_deleted = 1 AND last_modified < ${lastExportDate};`;
lastId = await UtilsSQLite.run(db, delStmt, [], true, 'no');
if (lastId < 0) {
return Promise.reject(new Error('DelExportedRows: lastId < 0'));
}
}
}
catch (err) {
return Promise.reject(new Error(`DelExportedRows failed: ${err.message}`));
}
}
static async modEmbeddedParentheses(sstr) {
const oParArray = UtilsExportJSON.indexOfChar(sstr, '(');
const cParArray = UtilsExportJSON.indexOfChar(sstr, ')');
if (oParArray.length != cParArray.length) {
return Promise.reject("ModEmbeddedParentheses: Not same number of '(' & ')'");
}
if (oParArray.length === 0) {
return Promise.resolve(sstr);
}
let resStmt = sstr.substring(0, oParArray[0] - 1);
for (let i = 0; i < oParArray.length; i++) {
let str;
if (i < oParArray.length - 1) {
if (oParArray[i + 1] < cParArray[i]) {
str = sstr.substring(oParArray[i] - 1, cParArray[i + 1]);
i++;
}
else {
str = sstr.substring(oParArray[i] - 1, cParArray[i]);
}
}
else {
str = sstr.substring(oParArray[i] - 1, cParArray[i]);
}
const newS = str.replace(/,/g, "§");
resStmt += newS;
if (i < oParArray.length - 1) {
resStmt += sstr.substring(cParArray[i], oParArray[i + 1] - 1);
}
}
resStmt += sstr.substring(cParArray[cParArray.length - 1], sstr.length);
return Promise.resolve(resStmt);
}
static indexOfChar(str, char) {
let tmpArr = [...str];
char = char.toLowerCase();
return tmpArr.reduce((results, elem, idx) => elem.toLowerCase() === char ? [...results, idx] : results, []);
}
}
//# sourceMappingURL=utils-exportJson.js.map

894

dist/collection/utils/utils-importJson.js

@@ -5,507 +5,507 @@ import { UtilsSQLite } from "./utils-sqlite";

export class UtilsImportJSON {
static async createDatabaseSchema(mDB, jsonData) {
let changes = -1;
const version = jsonData.version;
try {
// set User Version PRAGMA
await UtilsSQLite.setVersion(mDB.mDb, version);
// DROP ALL when mode="full"
if (jsonData.mode === 'full') {
await UtilsDrop.dropAll(mDB.mDb);
}
// create database schema
changes = await UtilsImportJSON.createSchema(mDB, jsonData);
return Promise.resolve(changes);
static async createDatabaseSchema(mDB, jsonData) {
let changes = -1;
const version = jsonData.version;
try {
// set User Version PRAGMA
await UtilsSQLite.setVersion(mDB.mDb, version);
// DROP ALL when mode="full"
if (jsonData.mode === 'full') {
await UtilsDrop.dropAll(mDB.mDb);
}
// create database schema
changes = await UtilsImportJSON.createSchema(mDB, jsonData);
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('CreateDatabaseSchema: ' + `${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error('CreateDatabaseSchema: ' + `${err.message}`));
}
}
static async createSchema(mDB, jsonData) {
// create the database schema
let changes = 0;
const db = mDB.mDb;
try {
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
mDB.setIsTransActive(true);
}
catch (err) {
return Promise.reject(new Error(`CreateSchema: ${err.message}`));
}
const stmts = await UtilsImportJSON.createSchemaStatement(jsonData);
if (stmts.length > 0) {
const schemaStmt = stmts.join('\n');
try {
changes = await UtilsSQLite.execute(db, schemaStmt, true);
if (changes < 0) {
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}`));
}
}
}
catch (err) {
const msg = err.message;
static async createSchema(mDB, jsonData) {
// create the database schema
let changes = 0;
const db = mDB.mDb;
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.reject(new Error(`CreateSchema: ${msg}`));
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
mDB.setIsTransActive(true);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}: ${msg}`));
return Promise.reject(new Error(`CreateSchema: ${err.message}`));
}
}
}
try {
await UtilsSQLite.commitTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: commit ' + `${err.message}`));
}
}
static async createSchemaStatement(jsonData) {
const statements = [];
let isLastModified = false;
let isSqlDeleted = false;
// Prepare the statement to execute
try {
for (const jTable of jsonData.tables) {
if (jTable.schema != null && jTable.schema.length >= 1) {
// create table
statements.push('CREATE TABLE IF NOT EXISTS ' + `${jTable.name} (`);
for (let j = 0; j < jTable.schema.length; j++) {
if (j === jTable.schema.length - 1) {
if (jTable.schema[j].column) {
statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value}`);
if (jTable.schema[j].column === "last_modified") {
isLastModified = true;
const stmts = await UtilsImportJSON.createSchemaStatement(jsonData);
if (stmts.length > 0) {
const schemaStmt = stmts.join('\n');
try {
changes = await UtilsSQLite.execute(db, schemaStmt, true);
if (changes < 0) {
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}`));
}
}
if (jTable.schema[j].column === "sql_deleted") {
isSqlDeleted = true;
}
catch (err) {
const msg = err.message;
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.reject(new Error(`CreateSchema: ${msg}`));
}
}
else if (jTable.schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value}`);
}
else if (jTable.schema[j].constraint) {
statements.push(`CONSTRAINT ${jTable.schema[j].constraint} ${jTable.schema[j].value}`);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}: ${msg}`));
}
}
else {
if (jTable.schema[j].column) {
statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value},`);
}
else if (jTable.schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value},`);
}
else if (jTable.schema[j].primarykey) {
statements.push(`FOREIGN KEY ${jTable.schema[j].value},`);
}
else if (jTable.schema[j].constraint) {
statements.push(`CONSTRAINT ${jTable.schema[j].constraint} ${jTable.schema[j].value},`);
}
}
}
statements.push(');');
if (isLastModified && isSqlDeleted) {
// create trigger last_modified associated with the table
let trig = 'CREATE TRIGGER IF NOT EXISTS ';
trig += `${jTable.name}`;
trig += `_trigger_last_modified `;
trig += `AFTER UPDATE ON ${jTable.name} `;
trig += 'FOR EACH ROW WHEN NEW.last_modified < ';
trig += 'OLD.last_modified BEGIN UPDATE ';
trig += `${jTable.name} `;
trig += `SET last_modified = `;
trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";
statements.push(trig);
}
}
if (jTable.indexes != null && jTable.indexes.length >= 1) {
for (const jIndex of jTable.indexes) {
const tableName = jTable.name;
let stmt = `CREATE ${Object.keys(jIndex).includes('mode') ? jIndex.mode + ' ' : ''} INDEX IF NOT EXISTS `;
stmt += `${jIndex.name} ON ${tableName} (${jIndex.value});`;
statements.push(stmt);
}
try {
await UtilsSQLite.commitTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.resolve(changes);
}
if (jTable.triggers != null && jTable.triggers.length >= 1) {
for (const jTrg of jTable.triggers) {
const tableName = jTable.name;
if (jTrg.timeevent.toUpperCase().endsWith(" ON")) {
jTrg.timeevent = jTrg.timeevent.substring(0, jTrg.timeevent.length - 3);
}
let stmt = `CREATE TRIGGER IF NOT EXISTS `;
stmt += `${jTrg.name} ${jTrg.timeevent} ON ${tableName} `;
if (jTrg.condition)
stmt += `${jTrg.condition} `;
stmt += `${jTrg.logic};`;
statements.push(stmt);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: commit ' + `${err.message}`));
}
}
return Promise.resolve(statements);
}
catch (err) {
return Promise.reject(err);
}
}
static async createTablesData(mDB, jsonData, importProgress) {
let changes = 0;
let isValue = false;
let lastId = -1;
let msg = '';
let initChanges = -1;
const db = mDB.mDb;
try {
initChanges = await UtilsSQLite.dbChanges(db);
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
mDB.setIsTransActive(true);
}
catch (err) {
return Promise.reject(new Error(`createTablesData: ${err.message}`));
}
for (const jTable of jsonData.tables) {
if (jTable.values != null && jTable.values.length >= 1) {
// Create the table's data
static async createSchemaStatement(jsonData) {
const statements = [];
let isLastModified = false;
let isSqlDeleted = false;
// Prepare the statement to execute
try {
lastId = await UtilsImportJSON.createTableData(db, jTable, jsonData.mode);
const msg = `create table data ${jTable.name}`;
importProgress.emit({ progress: msg });
if (lastId < 0)
break;
isValue = true;
for (const jTable of jsonData.tables) {
if (jTable.schema != null && jTable.schema.length >= 1) {
// create table
statements.push('CREATE TABLE IF NOT EXISTS ' + `${jTable.name} (`);
for (let j = 0; j < jTable.schema.length; j++) {
if (j === jTable.schema.length - 1) {
if (jTable.schema[j].column) {
statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value}`);
if (jTable.schema[j].column === "last_modified") {
isLastModified = true;
}
if (jTable.schema[j].column === "sql_deleted") {
isSqlDeleted = true;
}
}
else if (jTable.schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value}`);
}
else if (jTable.schema[j].constraint) {
statements.push(`CONSTRAINT ${jTable.schema[j].constraint} ${jTable.schema[j].value}`);
}
}
else {
if (jTable.schema[j].column) {
statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value},`);
}
else if (jTable.schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value},`);
}
else if (jTable.schema[j].primarykey) {
statements.push(`FOREIGN KEY ${jTable.schema[j].value},`);
}
else if (jTable.schema[j].constraint) {
statements.push(`CONSTRAINT ${jTable.schema[j].constraint} ${jTable.schema[j].value},`);
}
}
}
statements.push(');');
if (isLastModified && isSqlDeleted) {
// create trigger last_modified associated with the table
let trig = 'CREATE TRIGGER IF NOT EXISTS ';
trig += `${jTable.name}`;
trig += `_trigger_last_modified `;
trig += `AFTER UPDATE ON ${jTable.name} `;
trig += 'FOR EACH ROW WHEN NEW.last_modified < ';
trig += 'OLD.last_modified BEGIN UPDATE ';
trig += `${jTable.name} `;
trig += `SET last_modified = `;
trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";
statements.push(trig);
}
}
if (jTable.indexes != null && jTable.indexes.length >= 1) {
for (const jIndex of jTable.indexes) {
const tableName = jTable.name;
let stmt = `CREATE ${Object.keys(jIndex).includes('mode') ? jIndex.mode + ' ' : ''} INDEX IF NOT EXISTS `;
stmt += `${jIndex.name} ON ${tableName} (${jIndex.value});`;
statements.push(stmt);
}
}
if (jTable.triggers != null && jTable.triggers.length >= 1) {
for (const jTrg of jTable.triggers) {
const tableName = jTable.name;
if (jTrg.timeevent.toUpperCase().endsWith(" ON")) {
jTrg.timeevent = jTrg.timeevent.substring(0, jTrg.timeevent.length - 3);
}
let stmt = `CREATE TRIGGER IF NOT EXISTS `;
stmt += `${jTrg.name} ${jTrg.timeevent} ON ${tableName} `;
if (jTrg.condition)
stmt += `${jTrg.condition} `;
stmt += `${jTrg.logic};`;
statements.push(stmt);
}
}
}
return Promise.resolve(statements);
}
catch (err) {
msg = err.message;
isValue = false;
break;
return Promise.reject(err);
}
}
}
if (isValue) {
try {
await UtilsSQLite.commitTransaction(db, true);
mDB.setIsTransActive(false);
changes = (await UtilsSQLite.dbChanges(db)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('CreateTablesData: ' + `${err.message}`));
}
}
else {
if (msg.length > 0) {
static async createTablesData(mDB, jsonData, importProgress) {
let changes = 0;
let isValue = false;
let lastId = -1;
let msg = '';
let initChanges = -1;
const db = mDB.mDb;
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.reject(new Error(`CreateTablesData: ${msg}`));
initChanges = await UtilsSQLite.dbChanges(db);
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
mDB.setIsTransActive(true);
}
catch (err) {
return Promise.reject(new Error('CreateTablesData: ' + `${err.message}: ${msg}`));
return Promise.reject(new Error(`createTablesData: ${err.message}`));
}
}
else {
// case were no values given
return Promise.resolve(0);
}
}
}
static async createTableData(db, table, mode) {
let lastId = -1;
try {
// Check if the table exists
const tableExists = await UtilsSQLite.isTableExists(db, table.name);
if (!tableExists) {
return Promise.reject(new Error('CreateTableData: Table ' + `${table.name} does not exist`));
}
// Get the column names and types
const tableNamesTypes = await UtilsJSON
.getTableColumnNamesTypes(db, table.name);
const tableColumnTypes = tableNamesTypes.types;
const tableColumnNames = tableNamesTypes.names;
if (tableColumnTypes.length === 0) {
return Promise.reject(new Error('CreateTableData: Table ' + `${table.name} info does not exist`));
}
// Loop on Table Values
for (let j = 0; j < table.values.length; j++) {
let row = table.values[j];
let isRun = true;
const stmt = await UtilsImportJSON
.createRowStatement(db, tableColumnNames, row, j, table.name, mode);
isRun = await UtilsImportJSON.checkUpdate(db, stmt, row, table.name, tableColumnNames);
if (isRun) {
if (stmt.substring(0, 6).toUpperCase() === "DELETE") {
row = [];
}
lastId = await UtilsSQLite.run(db, stmt, row, true, 'no');
if (lastId < 0) {
return Promise.reject(new Error('CreateTableData: lastId < 0'));
}
for (const jTable of jsonData.tables) {
if (jTable.values != null && jTable.values.length >= 1) {
// Create the table's data
try {
lastId = await UtilsImportJSON.createTableData(db, jTable, jsonData.mode);
const msg = `create table data ${jTable.name}`;
importProgress.emit({ progress: msg });
if (lastId < 0)
break;
isValue = true;
}
catch (err) {
msg = err.message;
isValue = false;
break;
}
}
}
if (isValue) {
try {
await UtilsSQLite.commitTransaction(db, true);
mDB.setIsTransActive(false);
changes = (await UtilsSQLite.dbChanges(db)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('CreateTablesData: ' + `${err.message}`));
}
}
else {
lastId = 0;
if (msg.length > 0) {
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.reject(new Error(`CreateTablesData: ${msg}`));
}
catch (err) {
return Promise.reject(new Error('CreateTablesData: ' + `${err.message}: ${msg}`));
}
}
else {
// case were no values given
return Promise.resolve(0);
}
}
}
return Promise.resolve(lastId);
}
catch (err) {
return Promise.reject(new Error(`CreateTableData: ${err.message}`));
}
}
static async createRowStatement(db, tColNames, row, j, tableName, mode) {
// Check the row number of columns
if (row.length != tColNames.length || row.length === 0 || tColNames.length === 0) {
return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
`values row ${j} not correct length`));
}
try {
const retisIdExists = await UtilsImportJSON.isIdExists(db, tableName, tColNames[0], row[0]);
let stmt;
if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
// Insert
const nameString = tColNames.join();
const questionMarkString = await UtilsImportJSON.createQuestionMarkString(tColNames.length);
stmt = `INSERT INTO ${tableName} (${nameString}) VALUES (`;
stmt += `${questionMarkString});`;
}
else {
// Update or Delete
let isUpdate = true;
const isColDeleted = (element) => element === `sql_deleted`;
const idxDelete = tColNames.findIndex(isColDeleted);
if (idxDelete >= 0) {
if (row[idxDelete] === 1) {
isUpdate = false;
stmt =
`DELETE FROM ${tableName} WHERE `;
if (typeof row[0] == "string") {
stmt +=
`${tColNames[0]} = '${row[0]}';`;
static async createTableData(db, table, mode) {
let lastId = -1;
try {
// Check if the table exists
const tableExists = await UtilsSQLite.isTableExists(db, table.name);
if (!tableExists) {
return Promise.reject(new Error('CreateTableData: Table ' + `${table.name} does not exist`));
}
else {
stmt +=
`${tColNames[0]} = ${row[0]};`;
// Get the column names and types
const tableNamesTypes = await UtilsJSON
.getTableColumnNamesTypes(db, table.name);
const tableColumnTypes = tableNamesTypes.types;
const tableColumnNames = tableNamesTypes.names;
if (tableColumnTypes.length === 0) {
return Promise.reject(new Error('CreateTableData: Table ' + `${table.name} info does not exist`));
}
}
// Loop on Table Values
for (let j = 0; j < table.values.length; j++) {
let row = table.values[j];
let isRun = true;
const stmt = await UtilsImportJSON
.createRowStatement(db, tableColumnNames, row, j, table.name, mode);
isRun = await UtilsImportJSON.checkUpdate(db, stmt, row, table.name, tableColumnNames);
if (isRun) {
if (stmt.substring(0, 6).toUpperCase() === "DELETE") {
row = [];
}
lastId = await UtilsSQLite.run(db, stmt, row, true, 'no');
if (lastId < 0) {
return Promise.reject(new Error('CreateTableData: lastId < 0'));
}
}
else {
lastId = 0;
}
}
return Promise.resolve(lastId);
}
if (isUpdate) {
// Update
const setString = await UtilsImportJSON.setNameForUpdate(tColNames);
if (setString.length === 0) {
return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
`values row ${j} not set to String`));
}
stmt =
`UPDATE ${tableName} SET ${setString} WHERE `;
if (typeof row[0] == "string") {
stmt +=
`${tColNames[0]} = '${row[0]}';`;
}
else {
stmt +=
`${tColNames[0]} = ${row[0]};`;
}
catch (err) {
return Promise.reject(new Error(`CreateTableData: ${err.message}`));
}
}
return Promise.resolve(stmt);
}
catch (err) {
return Promise.reject(new Error(`CreateRowStatement: ${err.message}`));
}
}
static async checkUpdate(db, stmt, values, tbName, tColNames) {
let isRun = true;
if (stmt.substring(0, 6) === "UPDATE") {
try {
let query = `SELECT * FROM ${tbName} WHERE `;
if (typeof values[0] == "string") {
query +=
`${tColNames[0]} = '${values[0]}';`;
static async createRowStatement(db, tColNames, row, j, tableName, mode) {
// Check the row number of columns
if (row.length != tColNames.length || row.length === 0 || tColNames.length === 0) {
return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
`values row ${j} not correct length`));
}
else {
query +=
`${tColNames[0]} = ${values[0]};`;
try {
const retisIdExists = await UtilsImportJSON.isIdExists(db, tableName, tColNames[0], row[0]);
let stmt;
if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
// Insert
const nameString = tColNames.join();
const questionMarkString = await UtilsImportJSON.createQuestionMarkString(tColNames.length);
stmt = `INSERT INTO ${tableName} (${nameString}) VALUES (`;
stmt += `${questionMarkString});`;
}
else {
// Update or Delete
let isUpdate = true;
const isColDeleted = (element) => element === `sql_deleted`;
const idxDelete = tColNames.findIndex(isColDeleted);
if (idxDelete >= 0) {
if (row[idxDelete] === 1) {
isUpdate = false;
stmt =
`DELETE FROM ${tableName} WHERE `;
if (typeof row[0] == "string") {
stmt +=
`${tColNames[0]} = '${row[0]}';`;
}
else {
stmt +=
`${tColNames[0]} = ${row[0]};`;
}
}
}
if (isUpdate) {
// Update
const setString = await UtilsImportJSON.setNameForUpdate(tColNames);
if (setString.length === 0) {
return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
`values row ${j} not set to String`));
}
stmt =
`UPDATE ${tableName} SET ${setString} WHERE `;
if (typeof row[0] == "string") {
stmt +=
`${tColNames[0]} = '${row[0]}';`;
}
else {
stmt +=
`${tColNames[0]} = ${row[0]};`;
}
}
}
return Promise.resolve(stmt);
}
const resQuery = await UtilsJSON.getValues(db, query, tbName);
let resValues = [];
if (resQuery.length > 0) {
resValues = resQuery[0];
catch (err) {
return Promise.reject(new Error(`CreateRowStatement: ${err.message}`));
}
if (values.length > 0 && resValues.length > 0
&& values.length === resValues.length) {
for (let i = 0; i < values.length; i++) {
if (values[i] !== resValues[i]) {
return Promise.resolve(true);
}
static async checkUpdate(db, stmt, values, tbName, tColNames) {
let isRun = true;
if (stmt.substring(0, 6) === "UPDATE") {
try {
let query = `SELECT * FROM ${tbName} WHERE `;
if (typeof values[0] == "string") {
query +=
`${tColNames[0]} = '${values[0]}';`;
}
else {
query +=
`${tColNames[0]} = ${values[0]};`;
}
const resQuery = await UtilsJSON.getValues(db, query, tbName);
let resValues = [];
if (resQuery.length > 0) {
resValues = resQuery[0];
}
if (values.length > 0 && resValues.length > 0
&& values.length === resValues.length) {
for (let i = 0; i < values.length; i++) {
if (values[i] !== resValues[i]) {
return Promise.resolve(true);
}
}
return Promise.resolve(false);
}
else {
const msg = "Both arrays not the same length";
return Promise.reject(new Error(`CheckUpdate: ${msg}`));
}
}
}
return Promise.resolve(false);
catch (err) {
return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
}
}
else {
const msg = "Both arrays not the same length";
return Promise.reject(new Error(`CheckUpdate: ${msg}`));
return Promise.resolve(isRun);
}
}
catch (err) {
return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
}
}
else {
return Promise.resolve(isRun);
}
}
static async isIdExists(db, dbName, firstColumnName, key) {
let ret = false;
let query = `SELECT ${firstColumnName} FROM ` +
`${dbName} WHERE ${firstColumnName} = `;
if (typeof key === 'number')
query += `${key};`;
if (typeof key === 'string')
query += `'${key}';`;
try {
const resQuery = await UtilsSQLite.queryAll(db, query, []);
if (resQuery.length === 1)
ret = true;
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(new Error(`IsIdExists: ${err.message}`));
}
}
static async isType(type, value) {
let ret = false;
if (type === 'NULL' && typeof value === 'object')
ret = true;
if (type === 'TEXT' && typeof value === 'string')
ret = true;
if (type === 'INTEGER' && typeof value === 'number')
ret = true;
if (type === 'REAL' && typeof value === 'number')
ret = true;
if (type === 'BLOB' && typeof value === 'string')
ret = true;
if (ret) {
return Promise.resolve();
}
else {
return Promise.reject(new Error('IsType: not a SQL Type'));
}
}
static async checkColumnTypes(tableTypes, rowValues) {
for (let i = 0; i < rowValues.length; i++) {
if (rowValues[i] != null) {
static async isIdExists(db, dbName, firstColumnName, key) {
let ret = false;
let query = `SELECT ${firstColumnName} FROM ` +
`${dbName} WHERE ${firstColumnName} = `;
if (typeof key === 'number')
query += `${key};`;
if (typeof key === 'string')
query += `'${key}';`;
try {
await UtilsImportJSON.isType(tableTypes[i], rowValues[i]);
const resQuery = await UtilsSQLite.queryAll(db, query, []);
if (resQuery.length === 1)
ret = true;
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(new Error('CheckColumnTypes: Type not found'));
return Promise.reject(new Error(`IsIdExists: ${err.message}`));
}
}
}
return Promise.resolve();
}
static async createQuestionMarkString(length) {
let retString = '';
for (let i = 0; i < length; i++) {
retString += '?,';
static async isType(type, value) {
let ret = false;
if (type === 'NULL' && typeof value === 'object')
ret = true;
if (type === 'TEXT' && typeof value === 'string')
ret = true;
if (type === 'INTEGER' && typeof value === 'number')
ret = true;
if (type === 'REAL' && typeof value === 'number')
ret = true;
if (type === 'BLOB' && typeof value === 'string')
ret = true;
if (ret) {
return Promise.resolve();
}
else {
return Promise.reject(new Error('IsType: not a SQL Type'));
}
}
if (retString.length > 1) {
retString = retString.slice(0, -1);
return Promise.resolve(retString);
static async checkColumnTypes(tableTypes, rowValues) {
for (let i = 0; i < rowValues.length; i++) {
if (rowValues[i] != null) {
try {
await UtilsImportJSON.isType(tableTypes[i], rowValues[i]);
}
catch (err) {
return Promise.reject(new Error('CheckColumnTypes: Type not found'));
}
}
}
return Promise.resolve();
}
else {
return Promise.reject(new Error('CreateQuestionMarkString: length = 0'));
static async createQuestionMarkString(length) {
let retString = '';
for (let i = 0; i < length; i++) {
retString += '?,';
}
if (retString.length > 1) {
retString = retString.slice(0, -1);
return Promise.resolve(retString);
}
else {
return Promise.reject(new Error('CreateQuestionMarkString: length = 0'));
}
}
}
static async setNameForUpdate(names) {
let retString = '';
for (const name of names) {
retString += `${name} = ? ,`;
static async setNameForUpdate(names) {
let retString = '';
for (const name of names) {
retString += `${name} = ? ,`;
}
if (retString.length > 1) {
retString = retString.slice(0, -1);
return Promise.resolve(retString);
}
else {
return Promise.reject(new Error('SetNameForUpdate: length = 0'));
}
}
if (retString.length > 1) {
retString = retString.slice(0, -1);
return Promise.resolve(retString);
}
else {
return Promise.reject(new Error('SetNameForUpdate: length = 0'));
}
}
static async createView(db, view) {
const stmt = `CREATE VIEW IF NOT EXISTS ${view.name} AS ${view.value};`;
try {
const changes = await UtilsSQLite.execute(db, stmt, true);
if (changes < 0) {
return Promise.reject(new Error(`CreateView: ${view.name} failed`));
}
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`CreateView: ${err.message}`));
}
}
static async createViews(mDB, jsonData) {
const db = mDB.mDb;
let isView = false;
let msg = '';
let initChanges = -1;
let changes = -1;
try {
initChanges = await UtilsSQLite.dbChanges(db);
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
mDB.setIsTransActive(true);
}
catch (err) {
return Promise.reject(new Error(`createViews: ${err.message}`));
}
for (const jView of jsonData.views) {
if (jView.value != null) {
// Create the view
static async createView(db, view) {
const stmt = `CREATE VIEW IF NOT EXISTS ${view.name} AS ${view.value};`;
try {
await UtilsImportJSON.createView(db, jView);
isView = true;
const changes = await UtilsSQLite.execute(db, stmt, true);
if (changes < 0) {
return Promise.reject(new Error(`CreateView: ${view.name} failed`));
}
return Promise.resolve();
}
catch (err) {
msg = err.message;
isView = false;
break;
return Promise.reject(new Error(`CreateView: ${err.message}`));
}
}
}
if (isView) {
try {
await UtilsSQLite.commitTransaction(db, true);
mDB.setIsTransActive(false);
changes = (await UtilsSQLite.dbChanges(db)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('createViews: ' + `${err.message}`));
}
}
else {
if (msg.length > 0) {
static async createViews(mDB, jsonData) {
const db = mDB.mDb;
let isView = false;
let msg = '';
let initChanges = -1;
let changes = -1;
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.reject(new Error(`createViews: ${msg}`));
initChanges = await UtilsSQLite.dbChanges(db);
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
mDB.setIsTransActive(true);
}
catch (err) {
return Promise.reject(new Error('createViews: ' + `${err.message}: ${msg}`));
return Promise.reject(new Error(`createViews: ${err.message}`));
}
}
else {
// case were no views given
return Promise.resolve(0);
}
for (const jView of jsonData.views) {
if (jView.value != null) {
// Create the view
try {
await UtilsImportJSON.createView(db, jView);
isView = true;
}
catch (err) {
msg = err.message;
isView = false;
break;
}
}
}
if (isView) {
try {
await UtilsSQLite.commitTransaction(db, true);
mDB.setIsTransActive(false);
changes = (await UtilsSQLite.dbChanges(db)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('createViews: ' + `${err.message}`));
}
}
else {
if (msg.length > 0) {
try {
await UtilsSQLite.rollbackTransaction(db, true);
mDB.setIsTransActive(false);
return Promise.reject(new Error(`createViews: ${msg}`));
}
catch (err) {
return Promise.reject(new Error('createViews: ' + `${err.message}: ${msg}`));
}
}
else {
// case were no views given
return Promise.resolve(0);
}
}
}
}
}
//# sourceMappingURL=utils-importJson.js.map

610

dist/collection/utils/utils-json.js
import { UtilsSQLite } from "./utils-sqlite";
export class UtilsJSON {
static async isJsonSQLite(obj) {
const keyFirstLevel = [
'database',
'version',
'overwrite',
'encrypted',
'mode',
'tables',
'views'
];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyFirstLevel.indexOf(key) === -1)
return false;
if (key === 'database' && typeof obj[key] != 'string')
return false;
if (key === 'version' && typeof obj[key] != 'number')
return false;
if (key === 'overwrite' && typeof obj[key] != 'boolean')
return false;
if (key === 'encrypted' && typeof obj[key] != 'boolean')
return false;
if (key === 'mode' && typeof obj[key] != 'string')
return false;
if (key === 'tables' && typeof obj[key] != 'object')
return false;
if (key === 'tables') {
for (const oKey of obj[key]) {
const retTable = await UtilsJSON.isTable(oKey);
if (!retTable)
static async isJsonSQLite(obj) {
const keyFirstLevel = [
'database',
'version',
'overwrite',
'encrypted',
'mode',
'tables',
'views'
];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyFirstLevel.indexOf(key) === -1)
return false;
if (key === 'database' && typeof obj[key] != 'string')
return false;
if (key === 'version' && typeof obj[key] != 'number')
return false;
if (key === 'overwrite' && typeof obj[key] != 'boolean')
return false;
if (key === 'encrypted' && typeof obj[key] != 'boolean')
return false;
if (key === 'mode' && typeof obj[key] != 'string')
return false;
if (key === 'tables' && typeof obj[key] != 'object')
return false;
if (key === 'tables') {
for (const oKey of obj[key]) {
const retTable = await UtilsJSON.isTable(oKey);
if (!retTable)
return false;
}
}
if (key === 'views' && typeof obj[key] != 'object')
return false;
if (key === 'views') {
for (const oKey of obj[key]) {
const retView = await UtilsJSON.isView(oKey);
if (!retView)
return false;
}
}
}
}
if (key === 'views' && typeof obj[key] != 'object')
return false;
if (key === 'views') {
for (const oKey of obj[key]) {
const retView = await UtilsJSON.isView(oKey);
if (!retView)
return true;
}
static async isTable(obj) {
const keyTableLevel = [
'name',
'schema',
'indexes',
'triggers',
'values',
];
let nbColumn = 0;
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyTableLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'schema' && typeof obj[key] != 'object')
return false;
if (key === 'indexes' && typeof obj[key] != 'object')
return false;
if (key === 'triggers' && typeof obj[key] != 'object')
return false;
if (key === 'values' && typeof obj[key] != 'object')
return false;
if (key === 'schema') {
obj['schema'].forEach((element) => {
if (element.column) {
nbColumn++;
}
});
for (let i = 0; i < nbColumn; i++) {
const retSchema = await UtilsJSON.isSchema(obj[key][i]);
if (!retSchema)
return false;
}
}
if (key === 'indexes') {
for (const oKey of obj[key]) {
const retIndexes = await UtilsJSON.isIndexes(oKey);
if (!retIndexes)
return false;
}
}
if (key === 'triggers') {
for (const oKey of obj[key]) {
const retTriggers = await UtilsJSON.isTriggers(oKey);
if (!retTriggers)
return false;
}
}
if (key === 'values') {
if (nbColumn > 0) {
for (const oKey of obj[key]) {
if (typeof oKey != 'object' || oKey.length != nbColumn)
return false;
}
}
}
}
}
return true;
}
return true;
}
static async isTable(obj) {
const keyTableLevel = [
'name',
'schema',
'indexes',
'triggers',
'values',
];
let nbColumn = 0;
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyTableLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'schema' && typeof obj[key] != 'object')
return false;
if (key === 'indexes' && typeof obj[key] != 'object')
return false;
if (key === 'triggers' && typeof obj[key] != 'object')
return false;
if (key === 'values' && typeof obj[key] != 'object')
return false;
if (key === 'schema') {
obj['schema'].forEach((element) => {
if (element.column) {
nbColumn++;
}
});
for (let i = 0; i < nbColumn; i++) {
const retSchema = await UtilsJSON.isSchema(obj[key][i]);
if (!retSchema)
static async isSchema(obj) {
const keySchemaLevel = [
'column',
'value',
'foreignkey',
'primarykey',
'constraint',
];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keySchemaLevel.indexOf(key) === -1)
return false;
if (key === 'column' && typeof obj[key] != 'string')
return false;
if (key === 'value' && typeof obj[key] != 'string')
return false;
if (key === 'foreignkey' && typeof obj[key] != 'string')
return false;
if (key === 'primarykey' && typeof obj[key] != 'string')
return false;
if (key === 'constraint' && typeof obj[key] != 'string')
return false;
}
}
if (key === 'indexes') {
for (const oKey of obj[key]) {
const retIndexes = await UtilsJSON.isIndexes(oKey);
if (!retIndexes)
return true;
}
static async isIndexes(obj) {
const keyIndexesLevel = ['name', 'value', 'mode'];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyIndexesLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'value' && typeof obj[key] != 'string')
return false;
if (key === 'mode' &&
(typeof obj[key] != 'string' || obj[key].toUpperCase() != 'UNIQUE'))
return false;
}
}
if (key === 'triggers') {
for (const oKey of obj[key]) {
const retTriggers = await UtilsJSON.isTriggers(oKey);
if (!retTriggers)
return true;
}
static async isTriggers(obj) {
const keyTriggersLevel = [
'name',
'timeevent',
'condition',
'logic',
];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyTriggersLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'timeevent' && typeof obj[key] != 'string')
return false;
if (key === 'condition' && typeof obj[key] != 'string')
return false;
if (key === 'logic' && typeof obj[key] != 'string')
return false;
}
}
if (key === 'values') {
if (nbColumn > 0) {
for (const oKey of obj[key]) {
if (typeof oKey != 'object' || oKey.length != nbColumn)
return false;
}
return true;
}
static async isView(obj) {
const keyViewLevel = ['name', 'value'];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyViewLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'value' && typeof obj[key] != 'string')
return false;
}
}
return true;
}
return true;
}
static async isSchema(obj) {
const keySchemaLevel = [
'column',
'value',
'foreignkey',
'primarykey',
'constraint',
];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keySchemaLevel.indexOf(key) === -1)
return false;
if (key === 'column' && typeof obj[key] != 'string')
return false;
if (key === 'value' && typeof obj[key] != 'string')
return false;
if (key === 'foreignkey' && typeof obj[key] != 'string')
return false;
if (key === 'primarykey' && typeof obj[key] != 'string')
return false;
if (key === 'constraint' && typeof obj[key] != 'string')
return false;
static async checkSchemaValidity(schema) {
for (let i = 0; i < schema.length; i++) {
const sch = {};
const keys = Object.keys(schema[i]);
if (keys.includes('column')) {
sch.column = schema[i].column;
}
if (keys.includes('value')) {
sch.value = schema[i].value;
}
if (keys.includes('foreignkey')) {
sch.foreignkey = schema[i].foreignkey;
}
if (keys.includes('constraint')) {
sch.constraint = schema[i].constraint;
}
const isValid = await UtilsJSON.isSchema(sch);
if (!isValid) {
return Promise.reject(new Error(`CheckSchemaValidity: schema[${i}] not valid`));
}
}
return Promise.resolve();
}
return true;
}
static async isIndexes(obj) {
const keyIndexesLevel = ['name', 'value', 'mode'];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyIndexesLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'value' && typeof obj[key] != 'string')
return false;
if (key === 'mode' &&
(typeof obj[key] != 'string' || obj[key].toUpperCase() != 'UNIQUE'))
return false;
static async checkIndexesValidity(indexes) {
for (let i = 0; i < indexes.length; i++) {
const index = {};
const keys = Object.keys(indexes[i]);
if (keys.includes('value')) {
index.value = indexes[i].value;
}
if (keys.includes('name')) {
index.name = indexes[i].name;
}
if (keys.includes('mode')) {
index.mode = indexes[i].mode;
}
const isValid = await UtilsJSON.isIndexes(index);
if (!isValid) {
return Promise.reject(new Error(`CheckIndexesValidity: indexes[${i}] not valid`));
}
}
return Promise.resolve();
}
return true;
}
static async isTriggers(obj) {
const keyTriggersLevel = [
'name',
'timeevent',
'condition',
'logic',
];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyTriggersLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'timeevent' && typeof obj[key] != 'string')
return false;
if (key === 'condition' && typeof obj[key] != 'string')
return false;
if (key === 'logic' && typeof obj[key] != 'string')
return false;
static async checkTriggersValidity(triggers) {
for (let i = 0; i < triggers.length; i++) {
const trigger = {};
const keys = Object.keys(triggers[i]);
if (keys.includes('logic')) {
trigger.logic = triggers[i].logic;
}
if (keys.includes('name')) {
trigger.name = triggers[i].name;
}
if (keys.includes('timeevent')) {
trigger.timeevent = triggers[i].timeevent;
}
if (keys.includes('condition')) {
trigger.condition = triggers[i].condition;
}
const isValid = await UtilsJSON.isTriggers(trigger);
if (!isValid) {
return Promise.reject(new Error(`CheckTriggersValidity: triggers[${i}] not valid`));
}
}
return Promise.resolve();
}
return true;
}
static async isView(obj) {
const keyViewLevel = ['name', 'value'];
if (obj == null ||
(Object.keys(obj).length === 0 && obj.constructor === Object))
return false;
for (const key of Object.keys(obj)) {
if (keyViewLevel.indexOf(key) === -1)
return false;
if (key === 'name' && typeof obj[key] != 'string')
return false;
if (key === 'value' && typeof obj[key] != 'string')
return false;
static async checkViewsValidity(views) {
for (let i = 0; i < views.length; i++) {
const view = {};
const keys = Object.keys(views[i]);
if (keys.includes('value')) {
view.value = views[i].value;
}
if (keys.includes('name')) {
view.name = views[i].name;
}
const isValid = await UtilsJSON.isView(view);
if (!isValid) {
return Promise.reject(new Error(`CheckViewsValidity: views[${i}] not valid`));
}
}
return Promise.resolve();
}
return true;
}
static async checkSchemaValidity(schema) {
for (let i = 0; i < schema.length; i++) {
const sch = {};
const keys = Object.keys(schema[i]);
if (keys.includes('column')) {
sch.column = schema[i].column;
}
if (keys.includes('value')) {
sch.value = schema[i].value;
}
if (keys.includes('foreignkey')) {
sch.foreignkey = schema[i].foreignkey;
}
if (keys.includes('constraint')) {
sch.constraint = schema[i].constraint;
}
const isValid = await UtilsJSON.isSchema(sch);
if (!isValid) {
return Promise.reject(new Error(`CheckSchemaValidity: schema[${i}] not valid`));
}
}
return Promise.resolve();
}
static async checkIndexesValidity(indexes) {
for (let i = 0; i < indexes.length; i++) {
const index = {};
const keys = Object.keys(indexes[i]);
if (keys.includes('value')) {
index.value = indexes[i].value;
}
if (keys.includes('name')) {
index.name = indexes[i].name;
}
if (keys.includes('mode')) {
index.mode = indexes[i].mode;
}
const isValid = await UtilsJSON.isIndexes(index);
if (!isValid) {
return Promise.reject(new Error(`CheckIndexesValidity: indexes[${i}] not valid`));
}
}
return Promise.resolve();
}
static async checkTriggersValidity(triggers) {
for (let i = 0; i < triggers.length; i++) {
const trigger = {};
const keys = Object.keys(triggers[i]);
if (keys.includes('logic')) {
trigger.logic = triggers[i].logic;
}
if (keys.includes('name')) {
trigger.name = triggers[i].name;
}
if (keys.includes('timeevent')) {
trigger.timeevent = triggers[i].timeevent;
}
if (keys.includes('condition')) {
trigger.condition = triggers[i].condition;
}
const isValid = await UtilsJSON.isTriggers(trigger);
if (!isValid) {
return Promise.reject(new Error(`CheckTriggersValidity: triggers[${i}] not valid`));
}
}
return Promise.resolve();
}
static async checkViewsValidity(views) {
for (let i = 0; i < views.length; i++) {
const view = {};
const keys = Object.keys(views[i]);
if (keys.includes('value')) {
view.value = views[i].value;
}
if (keys.includes('name')) {
view.name = views[i].name;
}
const isValid = await UtilsJSON.isView(view);
if (!isValid) {
return Promise.reject(new Error(`CheckViewsValidity: views[${i}] not valid`));
}
}
return Promise.resolve();
}
static async getTableColumnNamesTypes(db, tableName) {
let resQuery = [];
const retNames = [];
const retTypes = [];
const query = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await UtilsSQLite.queryAll(db, query, []);
if (resQuery.length > 0) {
for (const query of resQuery) {
retNames.push(query.name);
retTypes.push(query.type);
static async getTableColumnNamesTypes(db, tableName) {
let resQuery = [];
const retNames = [];
const retTypes = [];
const query = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await UtilsSQLite.queryAll(db, query, []);
if (resQuery.length > 0) {
for (const query of resQuery) {
retNames.push(query.name);
retTypes.push(query.type);
}
}
return Promise.resolve({ names: retNames, types: retTypes });
}
}
return Promise.resolve({ names: retNames, types: retTypes });
catch (err) {
return Promise.reject(new Error('GetTableColumnNamesTypes: ' + `${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error('GetTableColumnNamesTypes: ' + `${err.message}`));
}
}
static async getValues(db, query, tableName) {
const values = [];
try {
// get table column names and types
const tableNamesTypes = await UtilsJSON.getTableColumnNamesTypes(db, tableName);
let rowNames = [];
if (Object.keys(tableNamesTypes).includes('names')) {
rowNames = tableNamesTypes.names;
}
else {
return Promise.reject(new Error(`GetValues: Table ${tableName} no names`));
}
const retValues = await UtilsSQLite.queryAll(db, query, []);
for (const rValue of retValues) {
const row = [];
for (const rName of rowNames) {
if (Object.keys(rValue).includes(rName)) {
row.push(rValue[rName]);
}
else {
row.push(null);
}
static async getValues(db, query, tableName) {
const values = [];
try {
// get table column names and types
const tableNamesTypes = await UtilsJSON.getTableColumnNamesTypes(db, tableName);
let rowNames = [];
if (Object.keys(tableNamesTypes).includes('names')) {
rowNames = tableNamesTypes.names;
}
else {
return Promise.reject(new Error(`GetValues: Table ${tableName} no names`));
}
const retValues = await UtilsSQLite.queryAll(db, query, []);
for (const rValue of retValues) {
const row = [];
for (const rName of rowNames) {
if (Object.keys(rValue).includes(rName)) {
row.push(rValue[rName]);
}
else {
row.push(null);
}
}
values.push(row);
}
return Promise.resolve(values);
}
values.push(row);
}
return Promise.resolve(values);
catch (err) {
return Promise.reject(new Error(`GetValues: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`GetValues: ${err.message}`));
}
}
}
//# sourceMappingURL=utils-json.js.map

938

dist/collection/utils/utils-sqlite.js

@@ -6,524 +6,524 @@ import { UtilsDrop } from "../utils/utils-drop";

export class UtilsSQLite {
static async beginTransaction(db, isOpen) {
const msg = 'BeginTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
static async beginTransaction(db, isOpen) {
const msg = 'BeginTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
}
try {
db.exec('BEGIN');
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`${msg}${err.message}`));
}
}
try {
db.exec('BEGIN');
return Promise.resolve();
static async rollbackTransaction(db, isOpen) {
const msg = 'RollbackTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
}
try {
db.exec('ROLLBACK');
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`${msg}${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`${msg}${err.message}`));
static commitTransaction(db, isOpen) {
const msg = 'CommitTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
}
const sql = 'COMMIT';
try {
db.exec(sql);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`${msg}${err.message}`));
}
}
}
static async rollbackTransaction(db, isOpen) {
const msg = 'RollbackTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
static async dbChanges(db) {
const SELECT_CHANGE = 'SELECT total_changes()';
let changes = 0;
try {
const res = db.exec(SELECT_CHANGE);
// process the row here
changes = res[0].values[0][0];
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error(`DbChanges failed: ${err.message}`));
}
}
try {
db.exec('ROLLBACK');
return Promise.resolve();
static async getLastId(db) {
const SELECT_LAST_ID = 'SELECT last_insert_rowid()';
let lastId = -1;
try {
const res = db.exec(SELECT_LAST_ID);
// process the row here
lastId = res[0].values[0][0];
return Promise.resolve(lastId);
}
catch (err) {
return Promise.reject(new Error(`GetLastId failed: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`${msg}${err.message}`));
static async setForeignKeyConstraintsEnabled(db, toggle) {
let stmt = 'PRAGMA foreign_keys=OFF';
if (toggle) {
stmt = 'PRAGMA foreign_keys=ON';
}
try {
db.run(stmt);
return Promise.resolve();
}
catch (err) {
const msg = err.message ? err.message : err;
return Promise.reject(new Error(`SetForeignKey: ${msg}`));
}
}
}
static commitTransaction(db, isOpen) {
const msg = 'CommitTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
static async getVersion(db) {
let version = 0;
try {
const res = db.exec('PRAGMA user_version;');
version = res[0].values[0][0];
return Promise.resolve(version);
}
catch (err) {
return Promise.reject(new Error(`GetVersion: ${err.message}`));
}
}
const sql = 'COMMIT';
try {
db.exec(sql);
return Promise.resolve();
static async setVersion(db, version) {
try {
db.exec(`PRAGMA user_version = ${version}`);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`SetVersion: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`${msg}${err.message}`));
static async execute(db, sql, fromJson) {
try {
var sqlStmt = sql;
// Check for DELETE FROM in sql string
if (!fromJson && sql.toLowerCase().includes('DELETE FROM'.toLowerCase())) {
sqlStmt = sql.replace(/\n/g, '');
let sqlStmts = sqlStmt.split(';');
var resArr = [];
for (const stmt of sqlStmts) {
const trimStmt = stmt.trim().substring(0, 11).toUpperCase();
if (trimStmt === 'DELETE FROM' && stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
const whereStmt = stmt.trim();
const rStmt = await UtilsSQLite.deleteSQL(db, whereStmt, []);
resArr.push(rStmt);
}
else {
resArr.push(stmt);
}
}
sqlStmt = resArr.join(';');
}
db.exec(sqlStmt);
const changes = await UtilsSQLite.dbChanges(db);
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error(`Execute: ${err.message}`));
}
}
}
static async dbChanges(db) {
const SELECT_CHANGE = 'SELECT total_changes()';
let changes = 0;
try {
const res = db.exec(SELECT_CHANGE);
// process the row here
changes = res[0].values[0][0];
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error(`DbChanges failed: ${err.message}`));
}
}
static async getLastId(db) {
const SELECT_LAST_ID = 'SELECT last_insert_rowid()';
let lastId = -1;
try {
const res = db.exec(SELECT_LAST_ID);
// process the row here
lastId = res[0].values[0][0];
return Promise.resolve(lastId);
}
catch (err) {
return Promise.reject(new Error(`GetLastId failed: ${err.message}`));
}
}
static async setForeignKeyConstraintsEnabled(db, toggle) {
let stmt = 'PRAGMA foreign_keys=OFF';
if (toggle) {
stmt = 'PRAGMA foreign_keys=ON';
}
try {
db.run(stmt);
return Promise.resolve();
}
catch (err) {
const msg = err.message ? err.message : err;
return Promise.reject(new Error(`SetForeignKey: ${msg}`));
}
}
static async getVersion(db) {
let version = 0;
try {
const res = db.exec('PRAGMA user_version;');
version = res[0].values[0][0];
return Promise.resolve(version);
}
catch (err) {
return Promise.reject(new Error(`GetVersion: ${err.message}`));
}
}
static async setVersion(db, version) {
try {
db.exec(`PRAGMA user_version = ${version}`);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`SetVersion: ${err.message}`));
}
}
static async execute(db, sql, fromJson) {
try {
var sqlStmt = sql;
// Check for DELETE FROM in sql string
if (!fromJson && sql.toLowerCase().includes('DELETE FROM'.toLowerCase())) {
sqlStmt = sql.replace(/\n/g, '');
let sqlStmts = sqlStmt.split(';');
var resArr = [];
for (const stmt of sqlStmts) {
const trimStmt = stmt.trim().substring(0, 11).toUpperCase();
if (trimStmt === 'DELETE FROM' && stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
const whereStmt = stmt.trim();
const rStmt = await UtilsSQLite.deleteSQL(db, whereStmt, []);
resArr.push(rStmt);
}
else {
resArr.push(stmt);
}
static async executeSet(db, set, fromJson, returnMode) {
const retValues = [];
let lastId = -1;
let retObj = {};
for (let i = 0; i < set.length; i++) {
const statement = 'statement' in set[i] ? set[i].statement : null;
const values = 'values' in set[i] && set[i].values.length > 0 ? set[i].values : [];
if (statement == null) {
let msg = 'ExecuteSet: Error No statement';
msg += ` for index ${i}`;
return Promise.reject(new Error(msg));
}
try {
if (Array.isArray(values[0])) {
for (const val of values) {
const mVal = await UtilsSQLite.replaceUndefinedByNull(val);
retObj = await UtilsSQLite.run(db, statement, mVal, fromJson, returnMode);
lastId = retObj["lastId"];
if (Object.keys(retObj).includes("values") && retObj["values"].length > 0) {
retValues.push(retObj["values"]);
}
}
}
else {
const mVal = await UtilsSQLite.replaceUndefinedByNull(values);
retObj = await UtilsSQLite.run(db, statement, mVal, fromJson, returnMode);
lastId = retObj["lastId"];
if (Object.keys(retObj).includes("values") && retObj["values"].length > 0) {
retValues.push(retObj["values"]);
}
}
}
catch (err) {
return Promise.reject(new Error(`ExecuteSet: ${err.message}`));
}
}
sqlStmt = resArr.join(';');
}
db.exec(sqlStmt);
const changes = await UtilsSQLite.dbChanges(db);
return Promise.resolve(changes);
retObj["lastId"] = lastId;
retObj["values"] = returnMode === 'all' ? retValues :
returnMode === 'one' ? retValues[0] : [];
return Promise.resolve(retObj);
}
catch (err) {
return Promise.reject(new Error(`Execute: ${err.message}`));
}
}
static async executeSet(db, set, fromJson, returnMode) {
const retValues = [];
let lastId = -1;
let retObj = {};
for (let i = 0; i < set.length; i++) {
const statement = 'statement' in set[i] ? set[i].statement : null;
const values = 'values' in set[i] && set[i].values.length > 0 ? set[i].values : [];
if (statement == null) {
let msg = 'ExecuteSet: Error No statement';
msg += ` for index ${i}`;
return Promise.reject(new Error(msg));
}
try {
if (Array.isArray(values[0])) {
for (const val of values) {
const mVal = await UtilsSQLite.replaceUndefinedByNull(val);
retObj = await UtilsSQLite.run(db, statement, mVal, fromJson, returnMode);
lastId = retObj["lastId"];
if (Object.keys(retObj).includes("values") && retObj["values"].length > 0) {
retValues.push(retObj["values"]);
static async queryAll(db, sql, values) {
try {
let retArr = [];
if (values != null && values.length > 0) {
retArr = db.exec(sql, values);
}
}
else {
retArr = db.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);
}
else {
const mVal = await UtilsSQLite.replaceUndefinedByNull(values);
retObj = await UtilsSQLite.run(db, statement, mVal, fromJson, returnMode);
lastId = retObj["lastId"];
if (Object.keys(retObj).includes("values") && retObj["values"].length > 0) {
retValues.push(retObj["values"]);
}
catch (err) {
return Promise.reject(new Error(`queryAll: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`ExecuteSet: ${err.message}`));
}
}
retObj["lastId"] = lastId;
retObj["values"] = returnMode === 'all' ? retValues :
returnMode === 'one' ? retValues[0] : [];
return Promise.resolve(retObj);
}
static async queryAll(db, sql, values) {
try {
let retArr = [];
if (values != null && values.length > 0) {
retArr = db.exec(sql, values);
}
else {
retArr = db.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) {
return Promise.reject(new Error(`queryAll: ${err.message}`));
}
}
static async run(db, statement, values, fromJson, returnMode) {
let stmtType = statement.replace(/\n/g, "").trim().substring(0, 6).toUpperCase();
let sqlStmt = statement;
let retValues = [];
let retObj = {};
try {
if (!fromJson && stmtType === "DELETE") {
sqlStmt = await UtilsSQLite.deleteSQL(db, statement, values);
}
const mValues = values ? values : [];
if (mValues.length > 0) {
const mVal = await UtilsSQLite.replaceUndefinedByNull(mValues);
const res = db.exec(sqlStmt, mVal);
if (returnMode === "all" || returnMode === "one") {
if (res && res.length > 0) {
retValues = UtilsSQLite.getReturnedValues(res[0], returnMode);
}
else {
return Promise.reject(new Error(`run: ${sqlStmt} does not returned any change`));
}
static async run(db, statement, values, fromJson, returnMode) {
let stmtType = statement.replace(/\n/g, "").trim().substring(0, 6).toUpperCase();
let sqlStmt = statement;
let retValues = [];
let retObj = {};
try {
if (!fromJson && stmtType === "DELETE") {
sqlStmt = await UtilsSQLite.deleteSQL(db, statement, values);
}
const mValues = values ? values : [];
if (mValues.length > 0) {
const mVal = await UtilsSQLite.replaceUndefinedByNull(mValues);
const res = db.exec(sqlStmt, mVal);
if (returnMode === "all" || returnMode === "one") {
if (res && res.length > 0) {
retValues = UtilsSQLite.getReturnedValues(res[0], returnMode);
}
else {
return Promise.reject(new Error(`run: ${sqlStmt} does not returned any change`));
}
}
}
else {
const res = db.exec(sqlStmt);
if (returnMode === "all" || returnMode === "one") {
if (res && res.length > 0) {
retValues = UtilsSQLite.getReturnedValues(res[0], returnMode);
}
else {
return Promise.reject(new Error(`run: ${sqlStmt} does not returned any change`));
}
}
}
const lastId = await UtilsSQLite.getLastId(db);
retObj["lastId"] = lastId;
if (retValues != null && retValues.length > 0)
retObj["values"] = retValues;
return Promise.resolve(retObj);
}
}
else {
const res = db.exec(sqlStmt);
if (returnMode === "all" || returnMode === "one") {
if (res && res.length > 0) {
retValues = UtilsSQLite.getReturnedValues(res[0], returnMode);
}
else {
return Promise.reject(new Error(`run: ${sqlStmt} does not returned any change`));
}
catch (err) {
return Promise.reject(new Error(`run: ${err.message}`));
}
}
const lastId = await UtilsSQLite.getLastId(db);
retObj["lastId"] = lastId;
if (retValues != null && retValues.length > 0)
retObj["values"] = retValues;
return Promise.resolve(retObj);
}
catch (err) {
return Promise.reject(new Error(`run: ${err.message}`));
static getReturnedValues(result, returnMode) {
const retValues = [];
for (let i = 0; i < result.values.length; i++) {
let row = {};
for (let j = 0; j < result.columns.length; j++) {
row[result.columns[j]] = result.values[i][j];
}
retValues.push(row);
if (returnMode === 'one')
break;
}
return retValues;
}
}
static getReturnedValues(result, returnMode) {
const retValues = [];
for (let i = 0; i < result.values.length; i++) {
let row = {};
for (let j = 0; j < result.columns.length; j++) {
row[result.columns[j]] = result.values[i][j];
}
retValues.push(row);
if (returnMode === 'one')
break;
}
return retValues;
}
static async deleteSQL(db, statement, values) {
let sqlStmt = statement;
try {
const isLast = await UtilsSQLite.isLastModified(db, true);
const isDel = await UtilsSQLite.isSqlDeleted(db, true);
if (!isLast || !isDel) {
return sqlStmt;
}
// Replace DELETE by UPDATE
// set sql_deleted to 1 and the last_modified to
// timenow
const whereClause = UtilsSQLStatement.extractWhereClause(sqlStmt);
if (!whereClause) {
const msg = 'deleteSQL: cannot find a WHERE clause';
return Promise.reject(new Error(`${msg}`));
}
const tableName = UtilsSQLStatement.extractTableName(sqlStmt);
if (!tableName) {
const msg = 'deleteSQL: cannot find a WHERE clause';
return Promise.reject(new Error(`${msg}`));
}
const colNames = UtilsSQLStatement.extractColumnNames(whereClause);
if (colNames.length === 0) {
const msg = 'deleteSQL: Did not find column names in the WHERE Statement';
return Promise.reject(new Error(`${msg}`));
}
const setStmt = 'sql_deleted = 1';
// Find REFERENCES if any and update the sql_deleted
// column
const hasToUpdate = await UtilsDelete.findReferencesAndUpdate(db, tableName, whereClause, colNames, values);
if (hasToUpdate) {
const whereStmt = whereClause.endsWith(';')
? whereClause.slice(0, -1)
: whereClause;
sqlStmt = `UPDATE ${tableName} SET ${setStmt} WHERE ${whereStmt} AND sql_deleted = 0;`;
}
else {
sqlStmt = '';
}
return Promise.resolve(sqlStmt);
}
catch (err) {
let msg = err.message ? err.message : err;
return Promise.reject(new Error(`deleteSQL: ${msg}`));
}
}
static async getTableList(db) {
try {
const result = await UtilsDrop.getTablesNames(db);
return Promise.resolve(result);
}
catch (err) {
return Promise.reject(new Error(`getTableList: ${err.message}`));
}
}
static async isTableExists(db, tableName) {
try {
let statement = 'SELECT name FROM sqlite_master WHERE ';
statement += `type='table' AND name='${tableName}';`;
const res = await UtilsSQLite.queryAll(db, statement, []);
const ret = res.length > 0 ? true : false;
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(new Error(`isTableExists: ${err.message}`));
}
}
/**
* isLastModified
* @param db
* @param isOpen
*/
static async isLastModified(db, isOpen) {
if (!isOpen) {
return Promise.reject('isLastModified: database not opened');
}
try {
const tableList = await UtilsDrop.getTablesNames(db);
for (const table of tableList) {
const tableNamesTypes = await UtilsJSON
.getTableColumnNamesTypes(db, table);
const tableColumnNames = tableNamesTypes.names;
if (tableColumnNames.includes("last_modified")) {
return Promise.resolve(true);
static async deleteSQL(db, statement, values) {
let sqlStmt = statement;
try {
const isLast = await UtilsSQLite.isLastModified(db, true);
const isDel = await UtilsSQLite.isSqlDeleted(db, true);
if (!isLast || !isDel) {
return sqlStmt;
}
// Replace DELETE by UPDATE
// set sql_deleted to 1 and the last_modified to
// timenow
const whereClause = UtilsSQLStatement.extractWhereClause(sqlStmt);
if (!whereClause) {
const msg = 'deleteSQL: cannot find a WHERE clause';
return Promise.reject(new Error(`${msg}`));
}
const tableName = UtilsSQLStatement.extractTableName(sqlStmt);
if (!tableName) {
const msg = 'deleteSQL: cannot find a WHERE clause';
return Promise.reject(new Error(`${msg}`));
}
const colNames = UtilsSQLStatement.extractColumnNames(whereClause);
if (colNames.length === 0) {
const msg = 'deleteSQL: Did not find column names in the WHERE Statement';
return Promise.reject(new Error(`${msg}`));
}
const setStmt = 'sql_deleted = 1';
// Find REFERENCES if any and update the sql_deleted
// column
const hasToUpdate = await UtilsDelete.findReferencesAndUpdate(db, tableName, whereClause, colNames, values);
if (hasToUpdate) {
const whereStmt = whereClause.endsWith(';')
? whereClause.slice(0, -1)
: whereClause;
sqlStmt = `UPDATE ${tableName} SET ${setStmt} WHERE ${whereStmt} AND sql_deleted = 0;`;
}
else {
sqlStmt = '';
}
return Promise.resolve(sqlStmt);
}
}
catch (err) {
let msg = err.message ? err.message : err;
return Promise.reject(new Error(`deleteSQL: ${msg}`));
}
}
catch (err) {
return Promise.reject(`isLastModified: ${err}`);
}
}
/**
* isSqlDeleted
* @param db
* @param isOpen
*/
static async isSqlDeleted(db, isOpen) {
if (!isOpen) {
return Promise.reject('isSqlDeleted: database not opened');
}
try {
const tableList = await UtilsDrop.getTablesNames(db);
for (const table of tableList) {
const tableNamesTypes = await UtilsJSON
.getTableColumnNamesTypes(db, table);
const tableColumnNames = tableNamesTypes.names;
if (tableColumnNames.includes("sql_deleted")) {
return Promise.resolve(true);
static async getTableList(db) {
try {
const result = await UtilsDrop.getTablesNames(db);
return Promise.resolve(result);
}
}
catch (err) {
return Promise.reject(new Error(`getTableList: ${err.message}`));
}
}
catch (err) {
return Promise.reject(`isSqlDeleted: ${err}`);
}
}
static async replaceUndefinedByNull(values) {
const retValues = [];
for (const val of values) {
let mVal = val;
if (typeof val === 'undefined')
mVal = null;
retValues.push(mVal);
}
return Promise.resolve(retValues);
}
static async backupTables(db) {
const msg = 'BackupTables: ';
let alterTables = {};
try {
const tables = await UtilsDrop.getTablesNames(db);
for (const table of tables) {
static async isTableExists(db, tableName) {
try {
const colNames = await UtilsSQLite.backupTable(db, table);
alterTables[`${table}`] = colNames;
let statement = 'SELECT name FROM sqlite_master WHERE ';
statement += `type='table' AND name='${tableName}';`;
const res = await UtilsSQLite.queryAll(db, statement, []);
const ret = res.length > 0 ? true : false;
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(new Error(`${msg}table ${table}: ` + `${err.message}`));
return Promise.reject(new Error(`isTableExists: ${err.message}`));
}
}
return Promise.resolve(alterTables);
}
catch (err) {
return Promise.reject(new Error(`BackupTables: ${err.message}`));
}
}
static async backupTable(db, table) {
try {
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
// get the table's column names
const colNames = await UtilsSQLite.getTableColumnNames(db, table);
const tmpTable = `_temp_${table}`;
// Drop the tmpTable if exists
const delStmt = `DROP TABLE IF EXISTS ${tmpTable};`;
await UtilsSQLite.run(db, delStmt, [], false, 'no');
// prefix the table with _temp_
let stmt = `ALTER TABLE ${table} RENAME `;
stmt += `TO ${tmpTable};`;
const lastId = await UtilsSQLite.run(db, stmt, [], false, 'no');
if (lastId < 0) {
let msg = 'BackupTable: lastId < 0';
/**
* isLastModified
* @param db
* @param isOpen
*/
static async isLastModified(db, isOpen) {
if (!isOpen) {
return Promise.reject('isLastModified: database not opened');
}
try {
await UtilsSQLite.rollbackTransaction(db, true);
const tableList = await UtilsDrop.getTablesNames(db);
for (const table of tableList) {
const tableNamesTypes = await UtilsJSON
.getTableColumnNamesTypes(db, table);
const tableColumnNames = tableNamesTypes.names;
if (tableColumnNames.includes("last_modified")) {
return Promise.resolve(true);
}
}
}
catch (err) {
msg += `: ${err.message}`;
return Promise.reject(`isLastModified: ${err}`);
}
return Promise.reject(new Error(`${msg}`));
}
else {
}
/**
* isSqlDeleted
* @param db
* @param isOpen
*/
static async isSqlDeleted(db, isOpen) {
if (!isOpen) {
return Promise.reject('isSqlDeleted: database not opened');
}
try {
await UtilsSQLite.commitTransaction(db, true);
return Promise.resolve(colNames);
const tableList = await UtilsDrop.getTablesNames(db);
for (const table of tableList) {
const tableNamesTypes = await UtilsJSON
.getTableColumnNamesTypes(db, table);
const tableColumnNames = tableNamesTypes.names;
if (tableColumnNames.includes("sql_deleted")) {
return Promise.resolve(true);
}
}
}
catch (err) {
return Promise.reject(new Error('BackupTable: ' + `${err.message}`));
return Promise.reject(`isSqlDeleted: ${err}`);
}
}
}
catch (err) {
return Promise.reject(new Error(`BackupTable: ${err.message}`));
static async replaceUndefinedByNull(values) {
const retValues = [];
for (const val of values) {
let mVal = val;
if (typeof val === 'undefined')
mVal = null;
retValues.push(mVal);
}
return Promise.resolve(retValues);
}
}
static async getTableColumnNames(db, tableName) {
let resQuery = [];
const retNames = [];
const query = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await UtilsSQLite.queryAll(db, query, []);
if (resQuery.length > 0) {
for (const query of resQuery) {
retNames.push(query.name);
static async backupTables(db) {
const msg = 'BackupTables: ';
let alterTables = {};
try {
const tables = await UtilsDrop.getTablesNames(db);
for (const table of tables) {
try {
const colNames = await UtilsSQLite.backupTable(db, table);
alterTables[`${table}`] = colNames;
}
catch (err) {
return Promise.reject(new Error(`${msg}table ${table}: ` + `${err.message}`));
}
}
return Promise.resolve(alterTables);
}
}
return Promise.resolve(retNames);
catch (err) {
return Promise.reject(new Error(`BackupTables: ${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error('GetTableColumnNames: ' + `${err.message}`));
static async backupTable(db, table) {
try {
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
// get the table's column names
const colNames = await UtilsSQLite.getTableColumnNames(db, table);
const tmpTable = `_temp_${table}`;
// Drop the tmpTable if exists
const delStmt = `DROP TABLE IF EXISTS ${tmpTable};`;
await UtilsSQLite.run(db, delStmt, [], false, 'no');
// prefix the table with _temp_
let stmt = `ALTER TABLE ${table} RENAME `;
stmt += `TO ${tmpTable};`;
const lastId = await UtilsSQLite.run(db, stmt, [], false, 'no');
if (lastId < 0) {
let msg = 'BackupTable: lastId < 0';
try {
await UtilsSQLite.rollbackTransaction(db, true);
}
catch (err) {
msg += `: ${err.message}`;
}
return Promise.reject(new Error(`${msg}`));
}
else {
try {
await UtilsSQLite.commitTransaction(db, true);
return Promise.resolve(colNames);
}
catch (err) {
return Promise.reject(new Error('BackupTable: ' + `${err.message}`));
}
}
}
catch (err) {
return Promise.reject(new Error(`BackupTable: ${err.message}`));
}
}
}
static async findCommonColumns(db, alterTables) {
let commonColumns = {};
try {
// Get new table list
const tables = await UtilsDrop.getTablesNames(db);
if (tables.length === 0) {
return Promise.reject(new Error('FindCommonColumns: get ' + "table's names failed"));
}
for (const table of tables) {
// get the column's name
const tableNames = await UtilsSQLite.getTableColumnNames(db, table);
// find the common columns
const keys = Object.keys(alterTables);
if (keys.includes(table)) {
commonColumns[table] = UtilsSQLite.arraysIntersection(alterTables[table], tableNames);
static async getTableColumnNames(db, tableName) {
let resQuery = [];
const retNames = [];
const query = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await UtilsSQLite.queryAll(db, query, []);
if (resQuery.length > 0) {
for (const query of resQuery) {
retNames.push(query.name);
}
}
return Promise.resolve(retNames);
}
}
return Promise.resolve(commonColumns);
catch (err) {
return Promise.reject(new Error('GetTableColumnNames: ' + `${err.message}`));
}
}
catch (err) {
return Promise.reject(new Error(`FindCommonColumns: ${err.message}`));
}
}
static arraysIntersection(a1, a2) {
if (a1 != null && a2 != null) {
const first = new Set(a1);
const second = new Set(a2);
return [...first].filter(item => second.has(item));
}
else {
return [];
}
}
static async updateNewTablesData(db, commonColumns) {
try {
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
const statements = [];
const keys = Object.keys(commonColumns);
keys.forEach(key => {
const columns = commonColumns[key].join(',');
let stmt = `INSERT INTO ${key} `;
stmt += `(${columns}) `;
stmt += `SELECT ${columns} FROM _temp_${key};`;
statements.push(stmt);
});
const changes = await UtilsSQLite.execute(db, statements.join('\n'), false);
if (changes < 0) {
let msg = 'updateNewTablesData: ' + 'changes < 0';
static async findCommonColumns(db, alterTables) {
let commonColumns = {};
try {
await UtilsSQLite.rollbackTransaction(db, true);
// Get new table list
const tables = await UtilsDrop.getTablesNames(db);
if (tables.length === 0) {
return Promise.reject(new Error('FindCommonColumns: get ' + "table's names failed"));
}
for (const table of tables) {
// get the column's name
const tableNames = await UtilsSQLite.getTableColumnNames(db, table);
// find the common columns
const keys = Object.keys(alterTables);
if (keys.includes(table)) {
commonColumns[table] = UtilsSQLite.arraysIntersection(alterTables[table], tableNames);
}
}
return Promise.resolve(commonColumns);
}
catch (err) {
msg += `: ${err.message}`;
return Promise.reject(new Error(`FindCommonColumns: ${err.message}`));
}
return Promise.reject(new Error(`${msg}`));
}
else {
}
static arraysIntersection(a1, a2) {
if (a1 != null && a2 != null) {
const first = new Set(a1);
const second = new Set(a2);
return [...first].filter(item => second.has(item));
}
else {
return [];
}
}
static async updateNewTablesData(db, commonColumns) {
try {
await UtilsSQLite.commitTransaction(db, true);
return Promise.resolve();
// start a transaction
await UtilsSQLite.beginTransaction(db, true);
const statements = [];
const keys = Object.keys(commonColumns);
keys.forEach(key => {
const columns = commonColumns[key].join(',');
let stmt = `INSERT INTO ${key} `;
stmt += `(${columns}) `;
stmt += `SELECT ${columns} FROM _temp_${key};`;
statements.push(stmt);
});
const changes = await UtilsSQLite.execute(db, statements.join('\n'), false);
if (changes < 0) {
let msg = 'updateNewTablesData: ' + 'changes < 0';
try {
await UtilsSQLite.rollbackTransaction(db, true);
}
catch (err) {
msg += `: ${err.message}`;
}
return Promise.reject(new Error(`${msg}`));
}
else {
try {
await UtilsSQLite.commitTransaction(db, true);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
}
}
}
catch (err) {
return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
}
}
}
catch (err) {
return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
}
}
}
//# sourceMappingURL=utils-sqlite.js.map

408

dist/collection/utils/utils-sqlstatement.js
export class UtilsSQLStatement {
static extractTableName(statement) {
const pattern = /(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+([^\s]+)/i;
const match = statement.match(pattern);
if (match && match[1]) {
const tableName = match[1];
return tableName;
static extractTableName(statement) {
const pattern = /(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+([^\s]+)/i;
const match = statement.match(pattern);
if (match && match[1]) {
const tableName = match[1];
return tableName;
}
return null;
}
return null;
}
static extractWhereClause(statement) {
const pattern = /WHERE(.+?)(?:ORDER\s+BY|LIMIT|$)/i;
const match = statement.match(pattern);
if (match && match[1]) {
const whereClause = match[1].trim();
return whereClause;
static extractWhereClause(statement) {
const pattern = /WHERE(.+?)(?:ORDER\s+BY|LIMIT|$)/i;
const match = statement.match(pattern);
if (match && match[1]) {
const whereClause = match[1].trim();
return whereClause;
}
return null;
}
return null;
}
static addPrefixToWhereClause(whereClause, colNames, refNames, prefix) {
let columnValuePairs;
// TODO "OR" and "NOT"
if (whereClause.includes("AND")) {
// Split the WHERE clause based on the "AND" keyword
const subSequenceArray = whereClause.split("AND");
columnValuePairs = subSequenceArray.map((pair) => pair.trim());
static addPrefixToWhereClause(whereClause, colNames, refNames, prefix) {
let columnValuePairs;
// TODO "OR" and "NOT"
if (whereClause.includes("AND")) {
// Split the WHERE clause based on the "AND" keyword
const subSequenceArray = whereClause.split("AND");
columnValuePairs = subSequenceArray.map((pair) => pair.trim());
}
else {
columnValuePairs = [whereClause];
}
const modifiedPairs = columnValuePairs.map((pair) => {
const match = pair.match(/(\w+)\s*(=|<|<=|<>|>|>=|IN|BETWEEN|LIKE)\s*(.+)/);
if (!match) {
return pair;
}
const column = match[1].trim();
const operator = match[2].trim();
let value = match[3].trim();
let newColumn = column;
const index = UtilsSQLStatement.findIndexOfStringInArray(column, refNames);
if (index !== -1) {
newColumn = UtilsSQLStatement.getStringAtIndex(colNames, index);
}
const modifiedColumn = `${prefix}${newColumn}`;
const ret = `${modifiedColumn} ${operator} ${value}`;
return ret;
});
return modifiedPairs.join(" AND ");
}
else {
columnValuePairs = [whereClause];
static findIndexOfStringInArray(target, array) {
return array.indexOf(target);
}
const modifiedPairs = columnValuePairs.map((pair) => {
const match = pair.match(/(\w+)\s*(=|<|<=|<>|>|>=|IN|BETWEEN|LIKE)\s*(.+)/);
if (!match) {
return pair;
}
const column = match[1].trim();
const operator = match[2].trim();
let value = match[3].trim();
let newColumn = column;
const index = UtilsSQLStatement.findIndexOfStringInArray(column, refNames);
if (index !== -1) {
newColumn = UtilsSQLStatement.getStringAtIndex(colNames, index);
}
const modifiedColumn = `${prefix}${newColumn}`;
const ret = `${modifiedColumn} ${operator} ${value}`;
return ret;
});
return modifiedPairs.join(" AND ");
}
static findIndexOfStringInArray(target, array) {
return array.indexOf(target);
}
static getStringAtIndex(array, index) {
if (index >= 0 && index < array.length) {
return array[index];
}
else {
return undefined;
}
}
static extractForeignKeyInfo(sqlStatement) {
// Define the regular expression pattern for extracting the FOREIGN KEY clause
const foreignKeyPattern = /\bFOREIGN\s+KEY\s*\(([^)]+)\)\s+REFERENCES\s+(\w+)\s*\(([^)]+)\)\s+(ON\s+DELETE\s+(RESTRICT|CASCADE|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION))?/;
const matches = sqlStatement.match(foreignKeyPattern);
if (matches) {
const foreignKeyInfo = {
forKeys: matches[1].split(",").map(key => key.trim()),
tableName: matches[2],
refKeys: matches[3].split(",").map(key => key.trim()),
action: matches[5] ? matches[5] : "NO ACTION"
};
return foreignKeyInfo;
}
else {
throw new Error("extractForeignKeyInfo: No FOREIGN KEY found");
}
}
static extractColumnNames(whereClause) {
const keywords = new Set([
"AND", "OR", "IN", "VALUES", "LIKE", "BETWEEN", "NOT"
]);
const regex = /\b[a-zA-Z]\w*\b(?=\s*(?:<=?|>=?|<>?|=|AND|OR|BETWEEN|NOT|IN|LIKE))|\b[a-zA-Z]\w*\b\s+BETWEEN\s+'[^']+'\s+AND\s+'[^']+'|\(([^)]+)\)\s+IN\s+\(?\s*VALUES\s*\(/g;
let match;
const columns = [];
while ((match = regex.exec(whereClause)) !== null) {
const columnList = match[1];
if (columnList) {
const columnNamesArray = columnList.split(',');
for (const columnName of columnNamesArray) {
columns.push(columnName.trim());
static getStringAtIndex(array, index) {
if (index >= 0 && index < array.length) {
return array[index];
}
}
else {
const matchedText = match[0];
if (!keywords.has(matchedText.trim().toUpperCase())) {
columns.push(matchedText.trim());
else {
return undefined;
}
}
}
return columns;
}
static flattenMultilineString(input) {
const lines = input.split(/\r?\n/);
return lines.join(" ");
}
static getStmtAndRetColNames(sqlStmt, retMode) {
const retWord = "RETURNING";
const retStmtNames = { stmt: sqlStmt, names: "" };
const retWordIndex = sqlStmt.toUpperCase().indexOf(retWord);
if (retWordIndex !== -1) {
const prefix = sqlStmt.substring(0, retWordIndex);
retStmtNames.stmt = `${prefix};`;
if (retMode.substring(0, 2) === "wA") {
const suffix = sqlStmt.substring(retWordIndex + retWord.length);
const names = suffix.trim();
if (names.endsWith(";")) {
retStmtNames.names = names.substring(0, names.length - 1);
static extractForeignKeyInfo(sqlStatement) {
// Define the regular expression pattern for extracting the FOREIGN KEY clause
const foreignKeyPattern = /\bFOREIGN\s+KEY\s*\(([^)]+)\)\s+REFERENCES\s+(\w+)\s*\(([^)]+)\)\s+(ON\s+DELETE\s+(RESTRICT|CASCADE|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION))?/;
const matches = sqlStatement.match(foreignKeyPattern);
if (matches) {
const foreignKeyInfo = {
forKeys: matches[1].split(",").map(key => key.trim()),
tableName: matches[2],
refKeys: matches[3].split(",").map(key => key.trim()),
action: matches[5] ? matches[5] : "NO ACTION"
};
return foreignKeyInfo;
}
else {
retStmtNames.names = names;
throw new Error("extractForeignKeyInfo: No FOREIGN KEY found");
}
}
}
return retStmtNames;
}
static extractCombinedPrimaryKey(whereClause) {
const pattern = /WHERE\s*\((.+?)\)\s*(?:=|IN)\s*\((.+?)\)/g;
const regex = new RegExp(pattern);
const matches = whereClause.matchAll(regex);
const primaryKeySets = [];
for (const match of matches) {
const keysString = match[1].trim();
const keys = keysString.split(",").map((key) => key.trim());
primaryKeySets.push(keys);
static extractColumnNames(whereClause) {
const keywords = new Set([
"AND", "OR", "IN", "VALUES", "LIKE", "BETWEEN", "NOT"
]);
const regex = /\b[a-zA-Z]\w*\b(?=\s*(?:<=?|>=?|<>?|=|AND|OR|BETWEEN|NOT|IN|LIKE))|\b[a-zA-Z]\w*\b\s+BETWEEN\s+'[^']+'\s+AND\s+'[^']+'|\(([^)]+)\)\s+IN\s+\(?\s*VALUES\s*\(/g;
let match;
const columns = [];
while ((match = regex.exec(whereClause)) !== null) {
const columnList = match[1];
if (columnList) {
const columnNamesArray = columnList.split(',');
for (const columnName of columnNamesArray) {
columns.push(columnName.trim());
}
}
else {
const matchedText = match[0];
if (!keywords.has(matchedText.trim().toUpperCase())) {
columns.push(matchedText.trim());
}
}
}
return columns;
}
return primaryKeySets.length === 0 ? null : primaryKeySets;
}
static getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys) {
let retWhere = whStmt;
for (const grpKeys of keys) {
const repKeys = grpKeys.join(",") === withRefs.join(",") ? colNames : withRefs;
for (const [index, key] of grpKeys.entries()) {
retWhere = UtilsSQLStatement.replaceAllString(retWhere, key, repKeys[index]);
}
static flattenMultilineString(input) {
const lines = input.split(/\r?\n/);
return lines.join(" ");
}
return retWhere;
}
static replaceAllString(originalStr, searchStr, replaceStr) {
return originalStr.split(searchStr).join(replaceStr);
}
static indicesOf(str, searchStr, fromIndex = 0) {
// Helper function to find indices of a substring within a string
const indices = [];
let currentIndex = str.indexOf(searchStr, fromIndex);
while (currentIndex !== -1) {
indices.push(currentIndex);
currentIndex = str.indexOf(searchStr, currentIndex + 1);
static getStmtAndRetColNames(sqlStmt, retMode) {
const retWord = "RETURNING";
const retStmtNames = { stmt: sqlStmt, names: "" };
const retWordIndex = sqlStmt.toUpperCase().indexOf(retWord);
if (retWordIndex !== -1) {
const prefix = sqlStmt.substring(0, retWordIndex);
retStmtNames.stmt = `${prefix};`;
if (retMode.substring(0, 2) === "wA") {
const suffix = sqlStmt.substring(retWordIndex + retWord.length);
const names = suffix.trim();
if (names.endsWith(";")) {
retStmtNames.names = names.substring(0, names.length - 1);
}
else {
retStmtNames.names = names;
}
}
}
return retStmtNames;
}
return indices;
}
static getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames) {
let whereStmt = "";
let stmt = whStmt.substring(6);
for (let idx = 0; idx < withRefs.length; idx++) {
let colType = "withRefsNames";
let idxs = UtilsSQLStatement.indicesOf(stmt, withRefs[idx]);
if (idxs.length === 0) {
idxs = UtilsSQLStatement.indicesOf(stmt, colNames[idx]);
colType = "colNames";
}
if (idxs.length > 0) {
let valStr = "";
const indicesEqual = UtilsSQLStatement.indicesOf(stmt, "=", idxs[0]);
if (indicesEqual.length > 0) {
const indicesAnd = UtilsSQLStatement.indicesOf(stmt, "AND", indicesEqual[0]);
if (indicesAnd.length > 0) {
valStr = stmt.substring(indicesEqual[0] + 1, indicesAnd[0] - 1);
stmt = stmt.substring(indicesAnd[0] + 3);
}
else {
valStr = stmt.substring(indicesEqual[0] + 1);
}
if (idx > 0) {
whereStmt += " AND ";
}
if (colType === "withRefsNames") {
whereStmt += colNames[idx] + " = " + valStr;
}
else {
whereStmt += withRefs[idx] + " = " + valStr;
}
static extractCombinedPrimaryKey(whereClause) {
const pattern = /WHERE\s*\((.+?)\)\s*(?:=|IN)\s*\((.+?)\)/g;
const regex = new RegExp(pattern);
const matches = whereClause.matchAll(regex);
const primaryKeySets = [];
for (const match of matches) {
const keysString = match[1].trim();
const keys = keysString.split(",").map((key) => key.trim());
primaryKeySets.push(keys);
}
}
return primaryKeySets.length === 0 ? null : primaryKeySets;
}
whereStmt = "WHERE " + whereStmt;
return whereStmt;
}
static updateWhere(whStmt, withRefs, colNames) {
let whereStmt = "";
if (whStmt.length <= 0) {
return whereStmt;
static getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys) {
let retWhere = whStmt;
for (const grpKeys of keys) {
const repKeys = grpKeys.join(",") === withRefs.join(",") ? colNames : withRefs;
for (const [index, key] of grpKeys.entries()) {
retWhere = UtilsSQLStatement.replaceAllString(retWhere, key, repKeys[index]);
}
}
return retWhere;
}
if (whStmt.toUpperCase().substring(0, 5) !== "WHERE") {
return whereStmt;
static replaceAllString(originalStr, searchStr, replaceStr) {
return originalStr.split(searchStr).join(replaceStr);
}
if (withRefs.length === colNames.length) {
// get whereStmt for primary combined key
const keys = UtilsSQLStatement.extractCombinedPrimaryKey(whStmt);
if (keys) {
whereStmt = UtilsSQLStatement.getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys);
}
else {
// get for non primary combined key
whereStmt = UtilsSQLStatement.getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames);
}
static indicesOf(str, searchStr, fromIndex = 0) {
// Helper function to find indices of a substring within a string
const indices = [];
let currentIndex = str.indexOf(searchStr, fromIndex);
while (currentIndex !== -1) {
indices.push(currentIndex);
currentIndex = str.indexOf(searchStr, currentIndex + 1);
}
return indices;
}
return whereStmt;
}
static getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames) {
let whereStmt = "";
let stmt = whStmt.substring(6);
for (let idx = 0; idx < withRefs.length; idx++) {
let colType = "withRefsNames";
let idxs = UtilsSQLStatement.indicesOf(stmt, withRefs[idx]);
if (idxs.length === 0) {
idxs = UtilsSQLStatement.indicesOf(stmt, colNames[idx]);
colType = "colNames";
}
if (idxs.length > 0) {
let valStr = "";
const indicesEqual = UtilsSQLStatement.indicesOf(stmt, "=", idxs[0]);
if (indicesEqual.length > 0) {
const indicesAnd = UtilsSQLStatement.indicesOf(stmt, "AND", indicesEqual[0]);
if (indicesAnd.length > 0) {
valStr = stmt.substring(indicesEqual[0] + 1, indicesAnd[0] - 1);
stmt = stmt.substring(indicesAnd[0] + 3);
}
else {
valStr = stmt.substring(indicesEqual[0] + 1);
}
if (idx > 0) {
whereStmt += " AND ";
}
if (colType === "withRefsNames") {
whereStmt += colNames[idx] + " = " + valStr;
}
else {
whereStmt += withRefs[idx] + " = " + valStr;
}
}
}
}
whereStmt = "WHERE " + whereStmt;
return whereStmt;
}
static updateWhere(whStmt, withRefs, colNames) {
let whereStmt = "";
if (whStmt.length <= 0) {
return whereStmt;
}
if (whStmt.toUpperCase().substring(0, 5) !== "WHERE") {
return whereStmt;
}
if (withRefs.length === colNames.length) {
// get whereStmt for primary combined key
const keys = UtilsSQLStatement.extractCombinedPrimaryKey(whStmt);
if (keys) {
whereStmt = UtilsSQLStatement.getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys);
}
else {
// get for non primary combined key
whereStmt = UtilsSQLStatement.getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames);
}
}
return whereStmt;
}
}
UtilsSQLStatement.replaceString = (originalStr, searchStr, replaceStr) => {
const range = originalStr.indexOf(searchStr);
if (range !== -1) {
const modifiedStr = originalStr.substring(0, range) + replaceStr + originalStr.substring(range + searchStr.length);
return modifiedStr;
}
return originalStr;
const range = originalStr.indexOf(searchStr);
if (range !== -1) {
const modifiedStr = originalStr.substring(0, range) + replaceStr + originalStr.substring(range + searchStr.length);
return modifiedStr;
}
return originalStr;
};
//# sourceMappingURL=utils-sqlstatement.js.map

212

dist/collection/utils/utils-store.js
export class UtilsStore {
static async getDBFromStore(dbName, store) {
try {
const retDb = await store.getItem(dbName);
return Promise.resolve(retDb);
static async getDBFromStore(dbName, store) {
try {
const retDb = await store.getItem(dbName);
return Promise.resolve(retDb);
}
catch (err) {
return Promise.reject(`GetDBFromStore: ${err.message}`);
}
}
catch (err) {
return Promise.reject(`GetDBFromStore: ${err.message}`);
static async setInitialDBToStore(dbName, store) {
try {
// export the database
const data = null;
// store the database
await store.setItem(dbName, data);
return Promise.resolve();
}
catch (err) {
return Promise.reject(`SetInitialDBToStore: ${err.message}`);
}
}
}
static async setInitialDBToStore(dbName, store) {
try {
// export the database
const data = null;
// store the database
await store.setItem(dbName, data);
return Promise.resolve();
static async setDBToStore(mDb, dbName, store) {
try {
// export the database
const data = mDb.export();
// store the database
await UtilsStore.saveDBToStore(dbName, data, store);
return Promise.resolve();
}
catch (err) {
return Promise.reject(`SetDBToStore: ${err.message}`);
}
}
catch (err) {
return Promise.reject(`SetInitialDBToStore: ${err.message}`);
static async saveDBToStore(dbName, data, store) {
try {
// store the database
await store.setItem(dbName, data);
return Promise.resolve();
}
catch (err) {
return Promise.reject(`SaveDBToStore: ${err.message}`);
}
}
}
static async setDBToStore(mDb, dbName, store) {
try {
// export the database
const data = mDb.export();
// store the database
await UtilsStore.saveDBToStore(dbName, data, store);
return Promise.resolve();
static async removeDBFromStore(dbName, store) {
try {
await store.removeItem(dbName);
return Promise.resolve();
}
catch (err) {
return Promise.reject(`RemoveDBFromStore: ${err.message}`);
}
}
catch (err) {
return Promise.reject(`SetDBToStore: ${err.message}`);
static async isDBInStore(dbName, store) {
try {
const retDb = await store.getItem(dbName);
if (retDb != null && retDb.length > 0) {
return Promise.resolve(true);
}
else {
return Promise.resolve(false);
}
}
catch (err) {
return Promise.reject(`IsDBInStore: ${err}`);
}
}
}
static async saveDBToStore(dbName, data, store) {
try {
// store the database
await store.setItem(dbName, data);
return Promise.resolve();
static async restoreDBFromStore(dbName, prefix, store) {
const mFileName = `${prefix}-${dbName}`;
try {
// check if file exists
const isFilePre = await UtilsStore.isDBInStore(mFileName, store);
if (isFilePre) {
const isFile = await UtilsStore.isDBInStore(dbName, store);
if (isFile) {
const retDb = await UtilsStore.getDBFromStore(mFileName, store);
await UtilsStore.saveDBToStore(dbName, retDb, store);
await UtilsStore.removeDBFromStore(mFileName, store);
return Promise.resolve();
}
else {
return Promise.reject(new Error(`RestoreDBFromStore: ${dbName} does not exist`));
}
}
else {
return Promise.reject(new Error(`RestoreDBFromStore: ${mFileName} does not exist`));
}
}
catch (err) {
return Promise.reject(`RestoreDBFromStore: ${err.message}`);
}
}
catch (err) {
return Promise.reject(`SaveDBToStore: ${err.message}`);
static async copyDBToStore(dbName, toDb, store) {
try {
// check if file exists
const isFile = await UtilsStore.isDBInStore(dbName, store);
if (isFile) {
const retDb = await UtilsStore.getDBFromStore(dbName, store);
await UtilsStore.saveDBToStore(toDb, retDb, store);
return Promise.resolve();
}
else {
return Promise.reject(new Error(`CopyDBToStore: ${dbName} does not exist`));
}
}
catch (err) {
return Promise.reject(`CopyDBToStore: ${err.message}`);
}
}
}
static async removeDBFromStore(dbName, store) {
try {
await store.removeItem(dbName);
return Promise.resolve();
}
catch (err) {
return Promise.reject(`RemoveDBFromStore: ${err.message}`);
}
}
static async isDBInStore(dbName, store) {
try {
const retDb = await store.getItem(dbName);
if (retDb != null && retDb.length > 0) {
return Promise.resolve(true);
}
else {
return Promise.resolve(false);
}
}
catch (err) {
return Promise.reject(`IsDBInStore: ${err}`);
}
}
static async restoreDBFromStore(dbName, prefix, store) {
const mFileName = `${prefix}-${dbName}`;
try {
// check if file exists
const isFilePre = await UtilsStore.isDBInStore(mFileName, store);
if (isFilePre) {
const isFile = await UtilsStore.isDBInStore(dbName, store);
if (isFile) {
const retDb = await UtilsStore.getDBFromStore(mFileName, store);
await UtilsStore.saveDBToStore(dbName, retDb, store);
await UtilsStore.removeDBFromStore(mFileName, store);
return Promise.resolve();
static async getDBListFromStore(store) {
try {
const retDbList = await store.keys();
return Promise.resolve(retDbList);
}
else {
return Promise.reject(new Error(`RestoreDBFromStore: ${dbName} does not exist`));
catch (err) {
return Promise.reject(`GetDBListFromStore: ${err.message}`);
}
}
else {
return Promise.reject(new Error(`RestoreDBFromStore: ${mFileName} does not exist`));
}
}
catch (err) {
return Promise.reject(`RestoreDBFromStore: ${err.message}`);
}
}
static async copyDBToStore(dbName, toDb, store) {
try {
// check if file exists
const isFile = await UtilsStore.isDBInStore(dbName, store);
if (isFile) {
const retDb = await UtilsStore.getDBFromStore(dbName, store);
await UtilsStore.saveDBToStore(toDb, retDb, store);
return Promise.resolve();
}
else {
return Promise.reject(new Error(`CopyDBToStore: ${dbName} does not exist`));
}
}
catch (err) {
return Promise.reject(`CopyDBToStore: ${err.message}`);
}
}
static async getDBListFromStore(store) {
try {
const retDbList = await store.keys();
return Promise.resolve(retDbList);
}
catch (err) {
return Promise.reject(`GetDBListFromStore: ${err.message}`);
}
}
}
//# sourceMappingURL=utils-store.js.map

80

dist/collection/utils/utils-upgrade.js
import { UtilsSQLite } from "../utils/utils-sqlite";
export class UtilsUpgrade {
static async onUpgrade(mDB, vUpgDict, curVersion, targetVersion) {
let changes = -1;
const sortedKeys = new Int32Array(Object.keys(vUpgDict)
.map(item => parseInt(item)))
.sort();
for (const versionKey of sortedKeys) {
if (versionKey > curVersion && versionKey <= targetVersion) {
const statements = vUpgDict[versionKey].statements;
if (statements.length === 0) {
return Promise.reject('onUpgrade: statements not given');
static async onUpgrade(mDB, vUpgDict, curVersion, targetVersion) {
let changes = -1;
const sortedKeys = new Int32Array(Object.keys(vUpgDict)
.map(item => parseInt(item)))
.sort();
for (const versionKey of sortedKeys) {
if (versionKey > curVersion && versionKey <= targetVersion) {
const statements = vUpgDict[versionKey].statements;
if (statements.length === 0) {
return Promise.reject('onUpgrade: statements not given');
}
try {
// set Foreign Keys Off
await UtilsSQLite.setForeignKeyConstraintsEnabled(mDB.mDb, false);
const initChanges = await UtilsSQLite.dbChanges(mDB.mDb);
await UtilsUpgrade.executeStatementsProcess(mDB, statements);
await UtilsSQLite.setVersion(mDB.mDb, versionKey);
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(mDB.mDb, true);
changes = (await UtilsSQLite.dbChanges(mDB.mDb)) - initChanges;
}
catch (err) {
return Promise.reject(new Error(`onUpgrade: ${err.message}`));
}
}
}
return Promise.resolve(changes);
}
;
static async executeStatementsProcess(mDB, statements) {
try {
// set Foreign Keys Off
await UtilsSQLite.setForeignKeyConstraintsEnabled(mDB.mDb, false);
const initChanges = await UtilsSQLite.dbChanges(mDB.mDb);
await UtilsUpgrade.executeStatementsProcess(mDB, statements);
await UtilsSQLite.setVersion(mDB.mDb, versionKey);
// set Foreign Keys On
await UtilsSQLite.setForeignKeyConstraintsEnabled(mDB.mDb, true);
changes = (await UtilsSQLite.dbChanges(mDB.mDb)) - initChanges;
await UtilsSQLite.beginTransaction(mDB.mDb, true);
mDB.setIsTransActive(true);
for (const statement of statements) {
await UtilsSQLite.execute(mDB.mDb, statement, false);
}
await UtilsSQLite.commitTransaction(mDB.mDb, true);
mDB.setIsTransActive(false);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`onUpgrade: ${err.message}`));
await UtilsSQLite.rollbackTransaction(mDB.mDb, true);
mDB.setIsTransActive(false);
return Promise.reject(`ExecuteStatementProcess: ${err}`);
}
}
}
return Promise.resolve(changes);
}
;
static async executeStatementsProcess(mDB, statements) {
try {
await UtilsSQLite.beginTransaction(mDB.mDb, true);
mDB.setIsTransActive(true);
for (const statement of statements) {
await UtilsSQLite.execute(mDB.mDb, statement, false);
}
await UtilsSQLite.commitTransaction(mDB.mDb, true);
mDB.setIsTransActive(false);
return Promise.resolve();
}
catch (err) {
await UtilsSQLite.rollbackTransaction(mDB.mDb, true);
mDB.setIsTransActive(false);
return Promise.reject(`ExecuteStatementProcess: ${err}`);
}
}
}
//# sourceMappingURL=utils-upgrade.js.map

4

dist/components/jeep-sqlite.d.ts

@@ -5,4 +5,4 @@ import type { Components, JSX } from "../types/components";

export const JeepSqlite: {
prototype: JeepSqlite;
new (): JeepSqlite;
prototype: JeepSqlite;
new (): JeepSqlite;
};

@@ -9,0 +9,0 @@ /**

6

dist/esm/jeep-sqlite.js

@@ -1,6 +0,6 @@

import { p as promiseResolve, b as bootstrapLazy } from './index-0d1f3b13.js';
export { s as setNonce } from './index-0d1f3b13.js';
import { p as promiseResolve, b as bootstrapLazy } from './index-ffc65f19.js';
export { s as setNonce } from './index-ffc65f19.js';
/*
Stencil Client Patch Browser v4.3.0 | MIT Licensed | https://stenciljs.com
Stencil Client Patch Browser v4.9.0 | MIT Licensed | https://stenciljs.com
*/

@@ -7,0 +7,0 @@ const patchBrowser = () => {

4

dist/esm/loader.js

@@ -1,3 +0,3 @@

import { b as bootstrapLazy } from './index-0d1f3b13.js';
export { s as setNonce } from './index-0d1f3b13.js';
import { b as bootstrapLazy } from './index-ffc65f19.js';
export { s as setNonce } from './index-ffc65f19.js';

@@ -4,0 +4,0 @@ const defineCustomElements = (win, options) => {

2

dist/jeep-sqlite/jeep-sqlite.esm.js

@@ -1,2 +0,2 @@

import{p as e,b as t}from"./p-7a8ed680.js";export{s as setNonce}from"./p-7a8ed680.js";const a=()=>{const t=import.meta.url;const s={};if(t!==""){s.resourcesUrl=new URL(".",t).href}return e(s)};a().then((e=>t([["p-5ab03169",[[1,"jeep-sqlite",{autoSave:[516,"autosave"],typeOrm:[516,"typeorm"],wasmPath:[513,"wasmpath"],pickText:[513,"picktext"],saveText:[513,"savetext"],buttonOptions:[513,"buttonoptions"],innerAutoSave:[32],innerTypeOrm:[32],innerWasmPath:[32],innerPickText:[32],innerSaveText:[32],innerButtonOptions:[32],echo:[64],createConnection:[64],isConnection:[64],closeConnection:[64],open:[64],close:[64],getVersion:[64],beginTransaction:[64],commitTransaction:[64],rollbackTransaction:[64],isTransactionActive:[64],execute:[64],executeSet:[64],run:[64],query:[64],getTableList:[64],isDBExists:[64],isDBOpen:[64],deleteDatabase:[64],isStoreOpen:[64],copyFromAssets:[64],isTableExists:[64],createSyncTable:[64],getSyncDate:[64],setSyncDate:[64],isJsonValid:[64],importFromJson:[64],exportToJson:[64],deleteExportedRows:[64],addUpgradeStatement:[64],isDatabase:[64],getDatabaseList:[64],checkConnectionsConsistency:[64],saveToStore:[64],saveToLocalDisk:[64],getFromLocalDiskToStore:[64],getFromHTTPRequest:[64]},null,{autoSave:["parseAutoSave"],typeOrm:["parseTypeOrm"],wasmPath:["parseWasmPath"],pickText:["parsePickText"],saveText:["parseSaveText"],buttonOptions:["parseButtonOptions"]}]]]],e)));
import{p as e,b as t}from"./p-8938a358.js";export{s as setNonce}from"./p-8938a358.js";const a=()=>{const t=import.meta.url;const s={};if(t!==""){s.resourcesUrl=new URL(".",t).href}return e(s)};a().then((e=>t([["p-f47f1152",[[1,"jeep-sqlite",{autoSave:[516,"autosave"],typeOrm:[516,"typeorm"],wasmPath:[513,"wasmpath"],pickText:[513,"picktext"],saveText:[513,"savetext"],buttonOptions:[513,"buttonoptions"],innerAutoSave:[32],innerTypeOrm:[32],innerWasmPath:[32],innerPickText:[32],innerSaveText:[32],innerButtonOptions:[32],echo:[64],createConnection:[64],isConnection:[64],closeConnection:[64],open:[64],close:[64],getVersion:[64],beginTransaction:[64],commitTransaction:[64],rollbackTransaction:[64],isTransactionActive:[64],execute:[64],executeSet:[64],run:[64],query:[64],getTableList:[64],isDBExists:[64],isDBOpen:[64],deleteDatabase:[64],isStoreOpen:[64],copyFromAssets:[64],isTableExists:[64],createSyncTable:[64],getSyncDate:[64],setSyncDate:[64],isJsonValid:[64],importFromJson:[64],exportToJson:[64],deleteExportedRows:[64],addUpgradeStatement:[64],isDatabase:[64],getDatabaseList:[64],checkConnectionsConsistency:[64],saveToStore:[64],saveToLocalDisk:[64],getFromLocalDiskToStore:[64],getFromHTTPRequest:[64]},null,{autoSave:["parseAutoSave"],typeOrm:["parseTypeOrm"],wasmPath:["parseWasmPath"],pickText:["parsePickText"],saveText:["parseSaveText"],buttonOptions:["parseButtonOptions"]}]]]],e)));
//# sourceMappingURL=jeep-sqlite.esm.js.map

15

dist/types/components.d.ts

@@ -80,3 +80,18 @@ /* eslint-disable */

declare global {
interface HTMLJeepSqliteElementEventMap {
"jeepSqliteImportProgress": JsonProgressListener;
"jeepSqliteExportProgress": JsonProgressListener;
"jeepSqliteHTTPRequestEnded": HTTPRequestEndedListener;
"jeepSqlitePickDatabaseEnded": PickOrSaveDatabaseEndedListener;
"jeepSqliteSaveDatabaseToDisk": PickOrSaveDatabaseEndedListener;
}
interface HTMLJeepSqliteElement extends Components.JeepSqlite, HTMLStencilElement {
addEventListener<K extends keyof HTMLJeepSqliteElementEventMap>(type: K, listener: (this: HTMLJeepSqliteElement, ev: JeepSqliteCustomEvent<HTMLJeepSqliteElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
removeEventListener<K extends keyof HTMLJeepSqliteElementEventMap>(type: K, listener: (this: HTMLJeepSqliteElement, ev: JeepSqliteCustomEvent<HTMLJeepSqliteElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
}

@@ -83,0 +98,0 @@ var HTMLJeepSqliteElement: {

286

dist/types/components/jeep-sqlite/jeep-sqlite.d.ts
import { EventEmitter } from '../../stencil-public-runtime';
import { EchoOptions, ConnectionOptions, SQLiteOptions, SQLiteExecuteOptions, SQLiteQueryOptions, SQLiteRunOptions, SQLiteSetOptions, SQLiteTableOptions, SQLiteSyncDateOptions, SQLiteImportOptions, SQLiteExportOptions, SQLiteUpgradeOptions, AllConnectionsOptions, EchoResult, SQLiteChanges, SQLiteResult, SQLiteValues, SQLiteSyncDate, SQLiteJson, JsonProgressListener, SQLiteVersion, SQLiteFromAssetsOptions, SQLiteHTTPOptions, HTTPRequestEndedListener, PickOrSaveDatabaseEndedListener, SQLiteLocalDiskOptions, ButtonOptions } from '../../interfaces/interfaces';
export declare class JeepSqlite {
el: HTMLJeepSqliteElement;
/**
* AutoSave
*/
autoSave: boolean;
/**
* in use with TypeOrm
*/
typeOrm: boolean;
/**
* WasmPath
*/
wasmPath: string;
/**
* Pick Button Text
*/
pickText: string;
/**
* Save Button Text
*/
saveText: string;
/**
* Button Options
*/
buttonOptions: string;
innerAutoSave: boolean;
innerTypeOrm: boolean;
innerWasmPath: string;
innerPickText: string;
innerSaveText: string;
innerButtonOptions: ButtonOptions;
parseAutoSave(newValue: boolean): void;
parseTypeOrm(newValue: boolean): void;
parseWasmPath(newValue: string): void;
parsePickText(newValue: string): void;
parseSaveText(newValue: string): void;
parseButtonOptions(newValue: string): void;
importProgress: EventEmitter<JsonProgressListener>;
exportProgress: EventEmitter<JsonProgressListener>;
HTTPRequestEnded: EventEmitter<HTTPRequestEndedListener>;
PickDatabaseEnded: EventEmitter<PickOrSaveDatabaseEndedListener>;
SaveDatabaseEnded: EventEmitter<PickOrSaveDatabaseEndedListener>;
echo(options: EchoOptions): Promise<EchoResult>;
createConnection(options: ConnectionOptions): Promise<void>;
isConnection(options: SQLiteOptions): Promise<SQLiteResult>;
closeConnection(options: SQLiteOptions): Promise<void>;
open(options: SQLiteOptions): Promise<void>;
close(options: SQLiteOptions): Promise<void>;
getVersion(options: SQLiteOptions): Promise<SQLiteVersion>;
beginTransaction(options: SQLiteOptions): Promise<SQLiteChanges>;
commitTransaction(options: SQLiteOptions): Promise<SQLiteChanges>;
rollbackTransaction(options: SQLiteOptions): Promise<SQLiteChanges>;
isTransactionActive(options: SQLiteOptions): Promise<SQLiteResult>;
execute(options: SQLiteExecuteOptions): Promise<SQLiteChanges>;
executeSet(options: SQLiteSetOptions): Promise<SQLiteChanges>;
run(options: SQLiteRunOptions): Promise<SQLiteChanges>;
query(options: SQLiteQueryOptions): Promise<SQLiteValues>;
getTableList(options: SQLiteOptions): Promise<SQLiteValues>;
isDBExists(options: SQLiteOptions): Promise<SQLiteResult>;
isDBOpen(options: SQLiteOptions): Promise<SQLiteResult>;
deleteDatabase(options: SQLiteOptions): Promise<void>;
isStoreOpen(): Promise<boolean>;
copyFromAssets(options: SQLiteFromAssetsOptions): Promise<void>;
isTableExists(options: SQLiteTableOptions): Promise<SQLiteResult>;
createSyncTable(options: SQLiteOptions): Promise<SQLiteChanges>;
getSyncDate(options: SQLiteSyncDateOptions): Promise<SQLiteSyncDate>;
setSyncDate(options: SQLiteSyncDateOptions): Promise<void>;
isJsonValid(options: SQLiteImportOptions): Promise<SQLiteResult>;
importFromJson(options: SQLiteImportOptions): Promise<SQLiteChanges>;
exportToJson(options: SQLiteExportOptions): Promise<SQLiteJson>;
deleteExportedRows(options: SQLiteOptions): Promise<void>;
addUpgradeStatement(options: SQLiteUpgradeOptions): Promise<void>;
isDatabase(options: SQLiteOptions): Promise<SQLiteResult>;
getDatabaseList(): Promise<SQLiteValues>;
checkConnectionsConsistency(options: AllConnectionsOptions): Promise<SQLiteResult>;
saveToStore(options: SQLiteOptions): Promise<void>;
saveToLocalDisk(options: SQLiteOptions): Promise<void>;
getFromLocalDiskToStore(options: SQLiteLocalDiskOptions): Promise<void>;
getFromHTTPRequest(options: SQLiteHTTPOptions): Promise<void>;
private store;
private storeName;
private isStore;
private _dbDict;
private databaseList;
private _versionUpgrades;
private _element;
private _blob;
private _opts;
private _buttonSaveEl;
private _buttonPickEl;
private _overwrite;
connectedCallback(): void;
componentWillLoad(): void;
componentDidLoad(): Promise<void>;
private _createConnection;
private _isConnection;
private _closeConnection;
private _open;
private _close;
private _saveToStore;
_saveToLocalDisk(database: string): Promise<void>;
_getFromLocalDiskToStore(overwrite: boolean): Promise<void>;
private pickDatabase;
private saveFile;
private _getVersion;
private _beginTransaction;
private _commitTransaction;
private _rollbackTransaction;
private _isTransactionActive;
private _execute;
private _executeSet;
private _run;
private _query;
private _getTableList;
private _isDBExists;
private _isDBOpen;
private _deleteDatabase;
private _isTableExists;
private _createSyncTable;
private _getSyncDate;
private _setSyncDate;
_isJsonValid(jsonStrObj: string): Promise<SQLiteResult>;
_importFromJson(jsonStrObj: string): Promise<SQLiteChanges>;
_exportToJson(database: string, exportMode: string, readonly: boolean): Promise<SQLiteJson>;
_deleteExportedRows(database: string, readonly: boolean): Promise<void>;
_copyFromAssets(overwrite: boolean): Promise<void>;
_getFromHTTPRequest(url: string, overwrite: boolean): Promise<void>;
_isDatabase(database: string): Promise<SQLiteResult>;
_getDatabaseList(): Promise<SQLiteValues>;
_checkConnectionsConsistency(dbNames: string[], openModes: string[]): Promise<SQLiteResult>;
private _resetDbDict;
private symmetricDifference;
private unzipDatabase;
private retrieveDBFromZip;
private copyDatabase;
private loadJSON;
private openStore;
private setConfig;
private removePathSuffix;
private setPathSuffix;
private blob2uint;
private uint2blob;
render(): void;
el: HTMLJeepSqliteElement;
/**
* AutoSave
*/
autoSave: boolean;
/**
* in use with TypeOrm
*/
typeOrm: boolean;
/**
* WasmPath
*/
wasmPath: string;
/**
* Pick Button Text
*/
pickText: string;
/**
* Save Button Text
*/
saveText: string;
/**
* Button Options
*/
buttonOptions: string;
innerAutoSave: boolean;
innerTypeOrm: boolean;
innerWasmPath: string;
innerPickText: string;
innerSaveText: string;
innerButtonOptions: ButtonOptions;
parseAutoSave(newValue: boolean): void;
parseTypeOrm(newValue: boolean): void;
parseWasmPath(newValue: string): void;
parsePickText(newValue: string): void;
parseSaveText(newValue: string): void;
parseButtonOptions(newValue: string): void;
importProgress: EventEmitter<JsonProgressListener>;
exportProgress: EventEmitter<JsonProgressListener>;
HTTPRequestEnded: EventEmitter<HTTPRequestEndedListener>;
PickDatabaseEnded: EventEmitter<PickOrSaveDatabaseEndedListener>;
SaveDatabaseEnded: EventEmitter<PickOrSaveDatabaseEndedListener>;
echo(options: EchoOptions): Promise<EchoResult>;
createConnection(options: ConnectionOptions): Promise<void>;
isConnection(options: SQLiteOptions): Promise<SQLiteResult>;
closeConnection(options: SQLiteOptions): Promise<void>;
open(options: SQLiteOptions): Promise<void>;
close(options: SQLiteOptions): Promise<void>;
getVersion(options: SQLiteOptions): Promise<SQLiteVersion>;
beginTransaction(options: SQLiteOptions): Promise<SQLiteChanges>;
commitTransaction(options: SQLiteOptions): Promise<SQLiteChanges>;
rollbackTransaction(options: SQLiteOptions): Promise<SQLiteChanges>;
isTransactionActive(options: SQLiteOptions): Promise<SQLiteResult>;
execute(options: SQLiteExecuteOptions): Promise<SQLiteChanges>;
executeSet(options: SQLiteSetOptions): Promise<SQLiteChanges>;
run(options: SQLiteRunOptions): Promise<SQLiteChanges>;
query(options: SQLiteQueryOptions): Promise<SQLiteValues>;
getTableList(options: SQLiteOptions): Promise<SQLiteValues>;
isDBExists(options: SQLiteOptions): Promise<SQLiteResult>;
isDBOpen(options: SQLiteOptions): Promise<SQLiteResult>;
deleteDatabase(options: SQLiteOptions): Promise<void>;
isStoreOpen(): Promise<boolean>;
copyFromAssets(options: SQLiteFromAssetsOptions): Promise<void>;
isTableExists(options: SQLiteTableOptions): Promise<SQLiteResult>;
createSyncTable(options: SQLiteOptions): Promise<SQLiteChanges>;
getSyncDate(options: SQLiteSyncDateOptions): Promise<SQLiteSyncDate>;
setSyncDate(options: SQLiteSyncDateOptions): Promise<void>;
isJsonValid(options: SQLiteImportOptions): Promise<SQLiteResult>;
importFromJson(options: SQLiteImportOptions): Promise<SQLiteChanges>;
exportToJson(options: SQLiteExportOptions): Promise<SQLiteJson>;
deleteExportedRows(options: SQLiteOptions): Promise<void>;
addUpgradeStatement(options: SQLiteUpgradeOptions): Promise<void>;
isDatabase(options: SQLiteOptions): Promise<SQLiteResult>;
getDatabaseList(): Promise<SQLiteValues>;
checkConnectionsConsistency(options: AllConnectionsOptions): Promise<SQLiteResult>;
saveToStore(options: SQLiteOptions): Promise<void>;
saveToLocalDisk(options: SQLiteOptions): Promise<void>;
getFromLocalDiskToStore(options: SQLiteLocalDiskOptions): Promise<void>;
getFromHTTPRequest(options: SQLiteHTTPOptions): Promise<void>;
private store;
private storeName;
private isStore;
private _dbDict;
private databaseList;
private _versionUpgrades;
private _element;
private _blob;
private _opts;
private _buttonSaveEl;
private _buttonPickEl;
private _overwrite;
connectedCallback(): void;
componentWillLoad(): void;
componentDidLoad(): Promise<void>;
private _createConnection;
private _isConnection;
private _closeConnection;
private _open;
private _close;
private _saveToStore;
_saveToLocalDisk(database: string): Promise<void>;
_getFromLocalDiskToStore(overwrite: boolean): Promise<void>;
private pickDatabase;
private saveFile;
private _getVersion;
private _beginTransaction;
private _commitTransaction;
private _rollbackTransaction;
private _isTransactionActive;
private _execute;
private _executeSet;
private _run;
private _query;
private _getTableList;
private _isDBExists;
private _isDBOpen;
private _deleteDatabase;
private _isTableExists;
private _createSyncTable;
private _getSyncDate;
private _setSyncDate;
_isJsonValid(jsonStrObj: string): Promise<SQLiteResult>;
_importFromJson(jsonStrObj: string): Promise<SQLiteChanges>;
_exportToJson(database: string, exportMode: string, readonly: boolean): Promise<SQLiteJson>;
_deleteExportedRows(database: string, readonly: boolean): Promise<void>;
_copyFromAssets(overwrite: boolean): Promise<void>;
_getFromHTTPRequest(url: string, overwrite: boolean): Promise<void>;
_isDatabase(database: string): Promise<SQLiteResult>;
_getDatabaseList(): Promise<SQLiteValues>;
_checkConnectionsConsistency(dbNames: string[], openModes: string[]): Promise<SQLiteResult>;
private _resetDbDict;
private symmetricDifference;
private unzipDatabase;
private retrieveDBFromZip;
private copyDatabase;
private loadJSON;
private openStore;
private setConfig;
private removePathSuffix;
private setPathSuffix;
private blob2uint;
private uint2blob;
render(): void;
}

750

dist/types/interfaces/interfaces.d.ts
export interface EchoOptions {
/**
* String to be echoed
*/
value?: string;
/**
* String to be echoed
*/
value?: string;
}
export interface ConnectionOptions {
/**
* The database name
*/
database?: string;
/**
* The database version
*/
version?: number;
/**
* Set to true (database encryption) / false
*/
encrypted?: boolean;
/**
* Set the mode for database encryption
* ["encryption", "secret", "newsecret"]
*/
mode?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* The database version
*/
version?: number;
/**
* Set to true (database encryption) / false
*/
encrypted?: boolean;
/**
* Set the mode for database encryption
* ["encryption", "secret", "newsecret"]
*/
mode?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface AllConnectionsOptions {
/**
* the dbName of all connections
*/
dbNames?: string[];
/**
* the openMode ("RW" read&write, "RO" readonly) of all connections
*/
openModes?: string[];
/**
* the dbName of all connections
*/
dbNames?: string[];
/**
* the openMode ("RW" read&write, "RO" readonly) of all connections
*/
openModes?: string[];
}
export interface SQLiteOptions {
/**
* The database name
*/
database?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface SQLiteExecuteOptions {
/**
* The database name
*/
database?: string;
/**
* The batch of raw SQL statements as string
*/
statements?: string;
/**
* Enable / Disable transactions
* default Enable (true)
*/
transaction?: boolean;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* The batch of raw SQL statements as string
*/
statements?: string;
/**
* Enable / Disable transactions
* default Enable (true)
*/
transaction?: boolean;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface SQLiteSetOptions {
/**
* The database name
*/
database?: string;
/**
* The batch of raw SQL statements as Array of capSQLLiteSet
*/
set?: SQLiteSet[];
/**
* Enable / Disable transactions
* default Enable (true)
*/
transaction?: boolean;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* return mode
* default 'no'
* value 'all'
* value 'one' for Electron platform
* @since 5.0.5-3
*/
returnMode?: string;
/**
* The database name
*/
database?: string;
/**
* The batch of raw SQL statements as Array of capSQLLiteSet
*/
set?: SQLiteSet[];
/**
* Enable / Disable transactions
* default Enable (true)
*/
transaction?: boolean;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* return mode
* default 'no'
* value 'all'
* value 'one' for Electron platform
* @since 5.0.5-3
*/
returnMode?: string;
}
export interface SQLiteRunOptions {
/**
* The database name
*/
database?: string;
/**
* A statement
*/
statement?: string;
/**
* A set of values for a statement
*/
values?: any[];
/**
* Enable / Disable transactions
* default Enable (true)
*/
transaction?: boolean;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* return mode
* default 'no'
* value 'all'
* value 'one' for Electron platform
* @since 5.0.5-3
*/
returnMode?: string;
/**
* The database name
*/
database?: string;
/**
* A statement
*/
statement?: string;
/**
* A set of values for a statement
*/
values?: any[];
/**
* Enable / Disable transactions
* default Enable (true)
*/
transaction?: boolean;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* return mode
* default 'no'
* value 'all'
* value 'one' for Electron platform
* @since 5.0.5-3
*/
returnMode?: string;
}
export interface SQLiteQueryOptions {
/**
* The database name
*/
database?: string;
/**
* A statement
*/
statement?: string;
/**
* A set of values for a statement
*/
values?: any[];
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* A statement
*/
statement?: string;
/**
* A set of values for a statement
*/
values?: any[];
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface SQLiteSyncDateOptions {
/**
* The database name
*/
database?: string;
/**
* Set the synchronization date
* Format yyyy-MM-dd'T'HH:mm:ss.SSSZ
*/
syncdate?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* Set the synchronization date
* Format yyyy-MM-dd'T'HH:mm:ss.SSSZ
*/
syncdate?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface SQLiteTableOptions {
/**
* The database name
*/
database?: string;
/**
* The table name
*/
table?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* The table name
*/
table?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface SQLiteImportOptions {
/**
* Set the JSON object to import
*
*/
jsonstring?: string;
/**
* Set the JSON object to import
*
*/
jsonstring?: string;
}
export interface SQLiteExportOptions {
/**
* The database name
*/
database?: string;
/**
* Set the mode to export JSON Object:
* "full" or "partial"
*
*/
jsonexportmode?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
/**
* The database name
*/
database?: string;
/**
* Set the mode to export JSON Object:
* "full" or "partial"
*
*/
jsonexportmode?: string;
/**
* Set to true (database in read-only mode) / false
*/
readonly?: boolean;
}
export interface SQLiteUpgradeOptions {
/**
* The database name
*/
database?: string;
/**
* The upgrade options for version upgrade
* Array of length 1 to easiest the iOS plugin
*/
upgrade?: SQLiteVersionUpgrade[];
/**
* The database name
*/
database?: string;
/**
* The upgrade options for version upgrade
* Array of length 1 to easiest the iOS plugin
*/
upgrade?: SQLiteVersionUpgrade[];
}
export interface SQLiteVersionUpgrade {
toVersion: number;
statements: string[];
toVersion: number;
statements: string[];
}
export interface SQLiteSet {
/**
* A statement
*/
statement?: string;
/**
* the data values list as an Array
*/
values?: any[];
/**
* A statement
*/
statement?: string;
/**
* the data values list as an Array
*/
values?: any[];
}
export interface SQLiteHTTPOptions {
/**
* The url
*/
url?: string;
/**
* the overwrite value true/false default true
*/
overwrite?: boolean;
/**
* The url
*/
url?: string;
/**
* the overwrite value true/false default true
*/
overwrite?: boolean;
}
export interface SQLiteLocalDiskOptions {
/**
* the overwrite value true/false default true
*/
overwrite?: boolean;
/**
* the overwrite value true/false default true
*/
overwrite?: boolean;
}
export interface EchoResult {
/**
* String returned
*/
value?: string;
/**
* String returned
*/
value?: string;
}
export interface SQLiteResult {
/**
* result set to true when successful else false
*/
result?: boolean;
/**
* result set to true when successful else false
*/
result?: boolean;
}
export interface SQLiteVersion {
/**
* the returned database version
*/
version?: number;
/**
* the returned database version
*/
version?: number;
}
export interface SQLiteChanges {
/**
* a returned Changes
*/
changes?: Changes;
/**
* a returned Changes
*/
changes?: Changes;
}
export interface Changes {
/**
* the number of changes from an execute or run command
*/
changes?: number;
/**
* the lastId created from a run command
*/
lastId?: number;
/**
* values when RETURNING
*/
values?: any[];
/**
* the number of changes from an execute or run command
*/
changes?: number;
/**
* the lastId created from a run command
*/
lastId?: number;
/**
* values when RETURNING
*/
values?: any[];
}
export interface SQLiteValues {
/**
* the data values list as an Array
*/
values?: any[];
/**
* the data values list as an Array
*/
values?: any[];
}
export interface SQLiteSyncDate {
/**
* the synchronization date
*/
syncDate?: number;
/**
* the synchronization date
*/
syncDate?: number;
}
export interface SQLiteFromAssetsOptions {
/**
* the overwrite value true/false default true
*/
overwrite?: boolean;
/**
* the overwrite value true/false default true
*/
overwrite?: boolean;
}
export interface SQLiteJson {
/**
* an export JSON object
*/
export?: JsonSQLite;
/**
* an export JSON object
*/
export?: JsonSQLite;
}
export interface JsonSQLite {
/**
* The database name
*/
database: string;
/**
* The database version
*/
version: number;
/**
* Delete the database prior to import (default false)
*/
overwrite?: boolean;
/**
* Set to true (database encryption) / false
*/
encrypted: boolean;
/***
* Set the mode
* ["full", "partial"]
*/
mode: string;
/***
* Array of Table (JsonTable)
*/
tables: JsonTable[];
/***
* Array of View (JsonView)
*/
views?: JsonView[];
/**
* The database name
*/
database: string;
/**
* The database version
*/
version: number;
/**
* Delete the database prior to import (default false)
*/
overwrite?: boolean;
/**
* Set to true (database encryption) / false
*/
encrypted: boolean;
/***
* Set the mode
* ["full", "partial"]
*/
mode: string;
/***
* Array of Table (JsonTable)
*/
tables: JsonTable[];
/***
* Array of View (JsonView)
*/
views?: JsonView[];
}
export interface JsonTable {
/**
* The database name
*/
name: string;
/***
* Array of Schema (JsonColumn)
*/
schema?: JsonColumn[];
/***
* Array of Index (JsonIndex)
*/
indexes?: JsonIndex[];
/***
* Array of Trigger (JsonTrigger)
*/
triggers?: JsonTrigger[];
/***
* Array of Table data
*/
values?: any[][];
/**
* The database name
*/
name: string;
/***
* Array of Schema (JsonColumn)
*/
schema?: JsonColumn[];
/***
* Array of Index (JsonIndex)
*/
indexes?: JsonIndex[];
/***
* Array of Trigger (JsonTrigger)
*/
triggers?: JsonTrigger[];
/***
* Array of Table data
*/
values?: any[][];
}
export interface JsonColumn {
/**
* The column name
*/
column?: string;
/**
* The column data (type, unique, ...)
*/
value: string;
/**
* The column foreign key constraints
*/
foreignkey?: string;
/**
* the column constraint
*/
constraint?: string;
/**
* The column name
*/
column?: string;
/**
* The column data (type, unique, ...)
*/
value: string;
/**
* The column foreign key constraints
*/
foreignkey?: string;
/**
* the column constraint
*/
constraint?: string;
}
export interface JsonTrigger {
/**
* The trigger name
*/
name: string;
/**
* The trigger time event fired
*/
timeevent: string;
/**
* The trigger condition
*/
condition?: string;
/**
* The logic of the trigger
*/
logic: string;
/**
* The trigger name
*/
name: string;
/**
* The trigger time event fired
*/
timeevent: string;
/**
* The trigger condition
*/
condition?: string;
/**
* The logic of the trigger
*/
logic: string;
}
export interface JsonIndex {
/**
* The index name
*/
name: string;
/**
* The value of the index can have the following formats:
* email
* email ASC
* email, MobileNumber
* email ASC, MobileNumber DESC
*/
value: string;
/**
* the mode (Optional)
* UNIQUE
*/
mode?: string;
/**
* The index name
*/
name: string;
/**
* The value of the index can have the following formats:
* email
* email ASC
* email, MobileNumber
* email ASC, MobileNumber DESC
*/
value: string;
/**
* the mode (Optional)
* UNIQUE
*/
mode?: string;
}
export interface JsonProgressListener {
/**
* Progress message
*/
progress?: string;
/**
* Progress message
*/
progress?: string;
}
export interface HTTPRequestEndedListener {
/**
* Message
*/
message?: string;
/**
* Message
*/
message?: string;
}
export interface PickOrSaveDatabaseEndedListener {
/**
* Pick Database's name
*/
db_name?: string;
/**
* Message
*/
message?: string;
/**
* Pick Database's name
*/
db_name?: string;
/**
* Message
*/
message?: string;
}
export interface ButtonOptions {
top?: string;
right?: string;
color?: string;
backgroundColor?: string;
fontSize?: string;
padding?: string;
top?: string;
right?: string;
color?: string;
backgroundColor?: string;
fontSize?: string;
padding?: string;
}
export interface JsonView {
/**
* The view name
*/
name: string;
/**
* The view statement
*/
value: string;
/**
* The view name
*/
name: string;
/**
* The view statement
*/
value: string;
}

29

dist/types/stencil-public-runtime.d.ts

@@ -7,2 +7,12 @@ declare type CustomMethodDecorator<T> = (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;

/**
* When set to `true` this component will be form-associated. See
* https://stenciljs.com/docs/next/form-associated documentation on how to
* build form-associated Stencil components that integrate into forms like
* native browser elements such as `<input>` and `<textarea>`.
*
* The {@link AttachInternals} decorator allows for access to the
* `ElementInternals` object to modify the associated form.
*/
formAssociated?: boolean;
/**
* Tag name of the web component. Ideally, the tag name must be globally unique,

@@ -111,2 +121,5 @@ * so it's recommended to choose an unique prefix for all your components within the same collection.

}
export interface AttachInternalsDecorator {
(): PropertyDecorator;
}
export interface ListenDecorator {

@@ -181,2 +194,8 @@ (eventName: string, opts?: ListenOptions): CustomMethodDecorator<any>;

/**
* If the `formAssociated` option is set in options passed to the
* `@Component()` decorator then this decorator may be used to get access to the
* `ElementInternals` instance associated with the component.
*/
export declare const AttachInternals: AttachInternalsDecorator;
/**
* The `Listen()` decorator is for listening DOM events, including the ones

@@ -797,2 +816,5 @@ * dispatched from `@Events()`.

value?: string | string[] | number;
popoverTargetAction?: string;
popoverTargetElement?: Element | null;
popoverTarget?: string;
}

@@ -959,2 +981,5 @@ interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {

width?: number | string;
popoverTargetAction?: string;
popoverTargetElement?: Element | null;
popoverTarget?: string;
}

@@ -1123,2 +1148,3 @@ interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {

interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
height?: number;
media?: string;

@@ -1129,2 +1155,3 @@ sizes?: string;

type?: string;
width?: number;
}

@@ -1212,2 +1239,3 @@ interface StyleHTMLAttributes<T> extends HTMLAttributes<T> {

id?: string;
inert?: boolean;
lang?: string;

@@ -1221,2 +1249,3 @@ spellcheck?: 'true' | 'false' | any;

title?: string;
popover?: string | null;
inputMode?: string;

@@ -1223,0 +1252,0 @@ inputmode?: string;

72

dist/types/utils/database.d.ts
import { EventEmitter } from '../stencil-public-runtime';
import { SQLiteSet, JsonSQLite, SQLiteVersionUpgrade, JsonProgressListener } from '../interfaces/interfaces';
export declare class Database {
private _isDBOpen;
private dbName;
private store;
private version;
mDb: any;
private vUpgDict;
private autoSave;
private wasmPath;
private isBackup;
private isTransactionActive;
constructor(databaseName: string, version: number, upgDict: Record<number, SQLiteVersionUpgrade>, store: LocalForage, autoSave: boolean, wasmPath: string);
open(): Promise<void>;
isDBOpen(): boolean;
close(): Promise<void>;
saveToStore(setFK?: boolean): Promise<void>;
exportDB(): Promise<Uint8Array>;
getVersion(): Promise<number>;
isDBExists(database: string): Promise<boolean>;
deleteDB(database: string): Promise<void>;
beginTransaction(): Promise<number>;
commitTransaction(): Promise<number>;
rollbackTransaction(): Promise<number>;
isTransActive(): boolean;
setIsTransActive(value: boolean): void;
executeSQL(sql: string, transaction?: boolean): Promise<number>;
execSet(set: SQLiteSet[], transaction?: boolean, returnMode?: string): Promise<any>;
selectSQL(sql: string, values: string[]): Promise<any[]>;
runSQL(statement: string, values: any[], transaction: boolean, returnMode: string): Promise<any>;
getTableNames(): Promise<any[]>;
isTable(tableName: string): Promise<boolean>;
createSyncTable(): Promise<number>;
getSyncDate(): Promise<number>;
setSyncDate(syncDate: string): Promise<any>;
importJson(jsonData: JsonSQLite, importProgress: EventEmitter<JsonProgressListener>): Promise<any>;
exportJson(mode: string, exportProgress: EventEmitter<JsonProgressListener>): Promise<any>;
deleteExportedRows(): Promise<void>;
private _isDBOpen;
private dbName;
private store;
private version;
mDb: any;
private vUpgDict;
private autoSave;
private wasmPath;
private isBackup;
private isTransactionActive;
constructor(databaseName: string, version: number, upgDict: Record<number, SQLiteVersionUpgrade>, store: LocalForage, autoSave: boolean, wasmPath: string);
open(): Promise<void>;
isDBOpen(): boolean;
close(): Promise<void>;
saveToStore(setFK?: boolean): Promise<void>;
exportDB(): Promise<Uint8Array>;
getVersion(): Promise<number>;
isDBExists(database: string): Promise<boolean>;
deleteDB(database: string): Promise<void>;
beginTransaction(): Promise<number>;
commitTransaction(): Promise<number>;
rollbackTransaction(): Promise<number>;
isTransActive(): boolean;
setIsTransActive(value: boolean): void;
executeSQL(sql: string, transaction?: boolean): Promise<number>;
execSet(set: SQLiteSet[], transaction?: boolean, returnMode?: string): Promise<any>;
selectSQL(sql: string, values: string[]): Promise<any[]>;
runSQL(statement: string, values: any[], transaction: boolean, returnMode: string): Promise<any>;
getTableNames(): Promise<any[]>;
isTable(tableName: string): Promise<boolean>;
createSyncTable(): Promise<number>;
getSyncDate(): Promise<number>;
setSyncDate(syncDate: string): Promise<any>;
importJson(jsonData: JsonSQLite, importProgress: EventEmitter<JsonProgressListener>): Promise<any>;
exportJson(mode: string, exportProgress: EventEmitter<JsonProgressListener>): Promise<any>;
deleteExportedRows(): Promise<void>;
}

76

dist/types/utils/utils-delete.d.ts
import { Database } from "./database";
export declare class UtilsDelete {
static findReferencesAndUpdate(mDB: Database, tableName: string, whereStmt: string, initColNames: string[], values: any[]): Promise<boolean>;
static getReferences(db: any, tableName: string): Promise<{
tableWithRefs: string;
retRefs: string[];
}>;
static getRefs(sqlStatement: string): {
tableName: string;
foreignKeys: string[];
};
static getReferencedTableName(refValue: string): Promise<string>;
static searchForRelatedItems(mDB: Database, updTableName: string, tableName: string, whStmt: string, withRefsNames: string[], colNames: string[], values: any[]): Promise<{
key: string;
relatedItems: any[];
}>;
static upDateWhereForDefault(withRefsNames: string[], results: {
key: string;
relatedItems: any[];
}): Promise<{
setStmt: string;
uWhereStmt: string;
}>;
static upDateWhereForRestrict(results: {
key: string;
relatedItems: any[];
}): Promise<{
setStmt: string;
uWhereStmt: string;
}>;
static upDateWhereForCascade(results: {
key: string;
relatedItems: any[];
}): Promise<{
setStmt: string;
uWhereStmt: string;
}>;
static executeUpdateForDelete(mDB: Database, tableName: string, whereStmt: string, setStmt: string, colNames: string[], values: any[]): void;
static getCurrentTimeAsInteger(): number;
static checkValuesMatch(array1: string[], array2: string[]): boolean;
static findReferencesAndUpdate(mDB: Database, tableName: string, whereStmt: string, initColNames: string[], values: any[]): Promise<boolean>;
static getReferences(db: any, tableName: string): Promise<{
tableWithRefs: string;
retRefs: string[];
}>;
static getRefs(sqlStatement: string): {
tableName: string;
foreignKeys: string[];
};
static getReferencedTableName(refValue: string): Promise<string>;
static searchForRelatedItems(mDB: Database, updTableName: string, tableName: string, whStmt: string, withRefsNames: string[], colNames: string[], values: any[]): Promise<{
key: string;
relatedItems: any[];
}>;
static upDateWhereForDefault(withRefsNames: string[], results: {
key: string;
relatedItems: any[];
}): Promise<{
setStmt: string;
uWhereStmt: string;
}>;
static upDateWhereForRestrict(results: {
key: string;
relatedItems: any[];
}): Promise<{
setStmt: string;
uWhereStmt: string;
}>;
static upDateWhereForCascade(results: {
key: string;
relatedItems: any[];
}): Promise<{
setStmt: string;
uWhereStmt: string;
}>;
static executeUpdateForDelete(mDB: Database, tableName: string, whereStmt: string, setStmt: string, colNames: string[], values: any[]): void;
static getCurrentTimeAsInteger(): number;
static checkValuesMatch(array1: string[], array2: string[]): boolean;
}

10

dist/types/utils/utils-drop.d.ts
export declare class UtilsDrop {
static getTablesNames(db: any): Promise<string[]>;
static getViewsNames(mDb: any): Promise<string[]>;
static dropElements(db: any, type: string): Promise<void>;
static dropAll(db: any): Promise<void>;
static dropTempTables(db: any, alterTables: Record<string, string[]>): Promise<void>;
static getTablesNames(db: any): Promise<string[]>;
static getViewsNames(mDb: any): Promise<string[]>;
static dropElements(db: any, type: string): Promise<void>;
static dropAll(db: any): Promise<void>;
static dropTempTables(db: any, alterTables: Record<string, string[]>): Promise<void>;
}

32

dist/types/utils/utils-exportJson.d.ts
import { EventEmitter } from '../stencil-public-runtime';
import { JsonSQLite, JsonTable, JsonColumn, JsonIndex, JsonTrigger, JsonView, JsonProgressListener } from '../interfaces/interfaces';
export declare class UtilsExportJSON {
static createExportObject(db: any, sqlObj: JsonSQLite, exportProgress: EventEmitter<JsonProgressListener>): Promise<JsonSQLite>;
static getViewsName(mDb: any): Promise<JsonView[]>;
static getTablesFull(db: any, resTables: any[], exportProgress: EventEmitter<JsonProgressListener>): Promise<JsonTable[]>;
static getSchema(sqlStmt: string): Promise<JsonColumn[]>;
static getIndexes(db: any, tableName: string): Promise<JsonIndex[]>;
static getTriggers(db: any, tableName: string): Promise<JsonTrigger[]>;
static getTablesPartial(db: any, resTables: any[], exportProgress: EventEmitter<JsonProgressListener>): Promise<JsonTable[]>;
static getPartialModeData(db: any, resTables: any[]): Promise<any>;
static getTablesNameSQL(db: any): Promise<any[]>;
static getTablesModified(db: any, tables: any[], syncDate: number): Promise<any>;
static getSynchroDate(db: any): Promise<number>;
static getLastExportDate(db: any): Promise<number>;
static setLastExportDate(db: any, lastExportedDate: string): Promise<any>;
static delExportedRows(db: any): Promise<void>;
static modEmbeddedParentheses(sstr: string): Promise<string>;
static indexOfChar(str: string, char: string): number[];
static createExportObject(db: any, sqlObj: JsonSQLite, exportProgress: EventEmitter<JsonProgressListener>): Promise<JsonSQLite>;
static getViewsName(mDb: any): Promise<JsonView[]>;
static getTablesFull(db: any, resTables: any[], exportProgress: EventEmitter<JsonProgressListener>): Promise<JsonTable[]>;
static getSchema(sqlStmt: string): Promise<JsonColumn[]>;
static getIndexes(db: any, tableName: string): Promise<JsonIndex[]>;
static getTriggers(db: any, tableName: string): Promise<JsonTrigger[]>;
static getTablesPartial(db: any, resTables: any[], exportProgress: EventEmitter<JsonProgressListener>): Promise<JsonTable[]>;
static getPartialModeData(db: any, resTables: any[]): Promise<any>;
static getTablesNameSQL(db: any): Promise<any[]>;
static getTablesModified(db: any, tables: any[], syncDate: number): Promise<any>;
static getSynchroDate(db: any): Promise<number>;
static getLastExportDate(db: any): Promise<number>;
static setLastExportDate(db: any, lastExportedDate: string): Promise<any>;
static delExportedRows(db: any): Promise<void>;
static modEmbeddedParentheses(sstr: string): Promise<string>;
static indexOfChar(str: string, char: string): number[];
}

28

dist/types/utils/utils-importJson.d.ts

@@ -5,16 +5,16 @@ import { EventEmitter } from '../stencil-public-runtime';

export declare class UtilsImportJSON {
static createDatabaseSchema(mDB: Database, jsonData: JsonSQLite): Promise<number>;
static createSchema(mDB: Database, jsonData: any): Promise<number>;
static createSchemaStatement(jsonData: any): Promise<string[]>;
static createTablesData(mDB: Database, jsonData: JsonSQLite, importProgress: EventEmitter<JsonProgressListener>): Promise<number>;
static createTableData(db: any, table: any, mode: string): Promise<number>;
static createRowStatement(db: any, tColNames: string[], row: any[], j: number, tableName: string, mode: string): Promise<string>;
static checkUpdate(db: any, stmt: string, values: any[], tbName: string, tColNames: string[]): Promise<boolean>;
static isIdExists(db: any, dbName: string, firstColumnName: string, key: any): Promise<boolean>;
static isType(type: string, value: any): Promise<void>;
static checkColumnTypes(tableTypes: any[], rowValues: any[]): Promise<void>;
static createQuestionMarkString(length: number): Promise<string>;
static setNameForUpdate(names: string[]): Promise<string>;
static createView(db: any, view: JsonView): Promise<void>;
static createViews(mDB: Database, jsonData: JsonSQLite): Promise<number>;
static createDatabaseSchema(mDB: Database, jsonData: JsonSQLite): Promise<number>;
static createSchema(mDB: Database, jsonData: any): Promise<number>;
static createSchemaStatement(jsonData: any): Promise<string[]>;
static createTablesData(mDB: Database, jsonData: JsonSQLite, importProgress: EventEmitter<JsonProgressListener>): Promise<number>;
static createTableData(db: any, table: any, mode: string): Promise<number>;
static createRowStatement(db: any, tColNames: string[], row: any[], j: number, tableName: string, mode: string): Promise<string>;
static checkUpdate(db: any, stmt: string, values: any[], tbName: string, tColNames: string[]): Promise<boolean>;
static isIdExists(db: any, dbName: string, firstColumnName: string, key: any): Promise<boolean>;
static isType(type: string, value: any): Promise<void>;
static checkColumnTypes(tableTypes: any[], rowValues: any[]): Promise<void>;
static createQuestionMarkString(length: number): Promise<string>;
static setNameForUpdate(names: string[]): Promise<string>;
static createView(db: any, view: JsonView): Promise<void>;
static createViews(mDB: Database, jsonData: JsonSQLite): Promise<number>;
}

24

dist/types/utils/utils-json.d.ts
import { JsonColumn, JsonIndex, JsonTrigger, JsonView } from '../interfaces/interfaces';
export declare class UtilsJSON {
static isJsonSQLite(obj: any): Promise<boolean>;
static isTable(obj: any): Promise<boolean>;
static isSchema(obj: any): Promise<boolean>;
static isIndexes(obj: any): Promise<boolean>;
static isTriggers(obj: any): Promise<boolean>;
static isView(obj: any): Promise<boolean>;
static checkSchemaValidity(schema: JsonColumn[]): Promise<void>;
static checkIndexesValidity(indexes: JsonIndex[]): Promise<void>;
static checkTriggersValidity(triggers: JsonTrigger[]): Promise<void>;
static checkViewsValidity(views: JsonView[]): Promise<void>;
static getTableColumnNamesTypes(db: any, tableName: string): Promise<any>;
static getValues(db: any, query: string, tableName: string): Promise<any[]>;
static isJsonSQLite(obj: any): Promise<boolean>;
static isTable(obj: any): Promise<boolean>;
static isSchema(obj: any): Promise<boolean>;
static isIndexes(obj: any): Promise<boolean>;
static isTriggers(obj: any): Promise<boolean>;
static isView(obj: any): Promise<boolean>;
static checkSchemaValidity(schema: JsonColumn[]): Promise<void>;
static checkIndexesValidity(indexes: JsonIndex[]): Promise<void>;
static checkTriggersValidity(triggers: JsonTrigger[]): Promise<void>;
static checkViewsValidity(views: JsonView[]): Promise<void>;
static getTableColumnNamesTypes(db: any, tableName: string): Promise<any>;
static getValues(db: any, query: string, tableName: string): Promise<any[]>;
}

70

dist/types/utils/utils-sqlite.d.ts
export declare class UtilsSQLite {
static beginTransaction(db: any, isOpen: boolean): Promise<void>;
static rollbackTransaction(db: any, isOpen: boolean): Promise<void>;
static commitTransaction(db: any, isOpen: boolean): Promise<void>;
static dbChanges(db: any): Promise<number>;
static getLastId(db: any): Promise<number>;
static setForeignKeyConstraintsEnabled(db: any, toggle: boolean): Promise<void>;
static getVersion(db: any): Promise<number>;
static setVersion(db: any, version: number): Promise<void>;
static execute(db: any, sql: string, fromJson: boolean): Promise<number>;
static executeSet(db: any, set: any, fromJson: boolean, returnMode: string): Promise<any>;
static queryAll(db: any, sql: string, values: any[]): Promise<any[]>;
static run(db: any, statement: string, values: any[], fromJson: boolean, returnMode: string): Promise<any>;
static getReturnedValues(result: any, returnMode: string): any[];
static deleteSQL(db: any, statement: string, values: any[]): Promise<string>;
static getTableList(db: any): Promise<any[]>;
static isTableExists(db: any, tableName: string): Promise<boolean>;
/**
* isLastModified
* @param db
* @param isOpen
*/
static isLastModified(db: any, isOpen: boolean): Promise<boolean>;
/**
* isSqlDeleted
* @param db
* @param isOpen
*/
static isSqlDeleted(db: any, isOpen: boolean): Promise<boolean>;
static replaceUndefinedByNull(values: any[]): Promise<any[]>;
static backupTables(db: any): Promise<Record<string, string[]>>;
static backupTable(db: any, table: string): Promise<string[]>;
static getTableColumnNames(db: any, tableName: string): Promise<string[]>;
static findCommonColumns(db: any, alterTables: Record<string, string[]>): Promise<Record<string, string[]>>;
static arraysIntersection(a1: any[], a2: any[]): any[];
static updateNewTablesData(db: any, commonColumns: Record<string, string[]>): Promise<void>;
static beginTransaction(db: any, isOpen: boolean): Promise<void>;
static rollbackTransaction(db: any, isOpen: boolean): Promise<void>;
static commitTransaction(db: any, isOpen: boolean): Promise<void>;
static dbChanges(db: any): Promise<number>;
static getLastId(db: any): Promise<number>;
static setForeignKeyConstraintsEnabled(db: any, toggle: boolean): Promise<void>;
static getVersion(db: any): Promise<number>;
static setVersion(db: any, version: number): Promise<void>;
static execute(db: any, sql: string, fromJson: boolean): Promise<number>;
static executeSet(db: any, set: any, fromJson: boolean, returnMode: string): Promise<any>;
static queryAll(db: any, sql: string, values: any[]): Promise<any[]>;
static run(db: any, statement: string, values: any[], fromJson: boolean, returnMode: string): Promise<any>;
static getReturnedValues(result: any, returnMode: string): any[];
static deleteSQL(db: any, statement: string, values: any[]): Promise<string>;
static getTableList(db: any): Promise<any[]>;
static isTableExists(db: any, tableName: string): Promise<boolean>;
/**
* isLastModified
* @param db
* @param isOpen
*/
static isLastModified(db: any, isOpen: boolean): Promise<boolean>;
/**
* isSqlDeleted
* @param db
* @param isOpen
*/
static isSqlDeleted(db: any, isOpen: boolean): Promise<boolean>;
static replaceUndefinedByNull(values: any[]): Promise<any[]>;
static backupTables(db: any): Promise<Record<string, string[]>>;
static backupTable(db: any, table: string): Promise<string[]>;
static getTableColumnNames(db: any, tableName: string): Promise<string[]>;
static findCommonColumns(db: any, alterTables: Record<string, string[]>): Promise<Record<string, string[]>>;
static arraysIntersection(a1: any[], a2: any[]): any[];
static updateNewTablesData(db: any, commonColumns: Record<string, string[]>): Promise<void>;
}

48

dist/types/utils/utils-sqlstatement.d.ts
export declare class UtilsSQLStatement {
static extractTableName(statement: string): string | null;
static extractWhereClause(statement: string): string | null;
static addPrefixToWhereClause(whereClause: string, colNames: string[], refNames: string[], prefix: string): string;
static findIndexOfStringInArray(target: string, array: string[]): number;
static getStringAtIndex(array: string[], index: number): string | undefined;
static extractForeignKeyInfo(sqlStatement: string): {
forKeys: string[];
tableName: string;
refKeys: string[];
action: string;
};
static extractColumnNames(whereClause: string): string[];
static flattenMultilineString(input: string): string;
static getStmtAndRetColNames(sqlStmt: string, retMode: string): {
stmt: string;
names: string;
};
static extractCombinedPrimaryKey(whereClause: string): string[][] | null;
static getWhereStmtForCombinedPK(whStmt: string, withRefs: string[], colNames: string[], keys: string[][]): string;
static replaceAllString(originalStr: string, searchStr: string, replaceStr: string): string;
static replaceString: (originalStr: string, searchStr: string, replaceStr: string) => string;
static indicesOf(str: string, searchStr: string, fromIndex?: number): number[];
static getWhereStmtForNonCombinedPK(whStmt: string, withRefs: string[], colNames: string[]): string;
static updateWhere(whStmt: string, withRefs: string[], colNames: string[]): string;
static extractTableName(statement: string): string | null;
static extractWhereClause(statement: string): string | null;
static addPrefixToWhereClause(whereClause: string, colNames: string[], refNames: string[], prefix: string): string;
static findIndexOfStringInArray(target: string, array: string[]): number;
static getStringAtIndex(array: string[], index: number): string | undefined;
static extractForeignKeyInfo(sqlStatement: string): {
forKeys: string[];
tableName: string;
refKeys: string[];
action: string;
};
static extractColumnNames(whereClause: string): string[];
static flattenMultilineString(input: string): string;
static getStmtAndRetColNames(sqlStmt: string, retMode: string): {
stmt: string;
names: string;
};
static extractCombinedPrimaryKey(whereClause: string): string[][] | null;
static getWhereStmtForCombinedPK(whStmt: string, withRefs: string[], colNames: string[], keys: string[][]): string;
static replaceAllString(originalStr: string, searchStr: string, replaceStr: string): string;
static replaceString: (originalStr: string, searchStr: string, replaceStr: string) => string;
static indicesOf(str: string, searchStr: string, fromIndex?: number): number[];
static getWhereStmtForNonCombinedPK(whStmt: string, withRefs: string[], colNames: string[]): string;
static updateWhere(whStmt: string, withRefs: string[], colNames: string[]): string;
}

18

dist/types/utils/utils-store.d.ts
export declare class UtilsStore {
static getDBFromStore(dbName: string, store: LocalForage): Promise<Uint8Array>;
static setInitialDBToStore(dbName: string, store: LocalForage): Promise<void>;
static setDBToStore(mDb: any, dbName: string, store: LocalForage): Promise<void>;
static saveDBToStore(dbName: string, data: Uint8Array, store: LocalForage): Promise<void>;
static removeDBFromStore(dbName: string, store: LocalForage): Promise<void>;
static isDBInStore(dbName: string, store: LocalForage): Promise<boolean>;
static restoreDBFromStore(dbName: string, prefix: string, store: LocalForage): Promise<void>;
static copyDBToStore(dbName: string, toDb: string, store: LocalForage): Promise<void>;
static getDBListFromStore(store: LocalForage): Promise<string[]>;
static getDBFromStore(dbName: string, store: LocalForage): Promise<Uint8Array>;
static setInitialDBToStore(dbName: string, store: LocalForage): Promise<void>;
static setDBToStore(mDb: any, dbName: string, store: LocalForage): Promise<void>;
static saveDBToStore(dbName: string, data: Uint8Array, store: LocalForage): Promise<void>;
static removeDBFromStore(dbName: string, store: LocalForage): Promise<void>;
static isDBInStore(dbName: string, store: LocalForage): Promise<boolean>;
static restoreDBFromStore(dbName: string, prefix: string, store: LocalForage): Promise<void>;
static copyDBToStore(dbName: string, toDb: string, store: LocalForage): Promise<void>;
static getDBListFromStore(store: LocalForage): Promise<string[]>;
}

4

dist/types/utils/utils-upgrade.d.ts
import { SQLiteVersionUpgrade } from '../interfaces/interfaces';
import { Database } from './database';
export declare class UtilsUpgrade {
static onUpgrade(mDB: Database, vUpgDict: Record<number, SQLiteVersionUpgrade>, curVersion: number, targetVersion: number): Promise<number>;
static executeStatementsProcess(mDB: Database, statements: string[]): Promise<void>;
static onUpgrade(mDB: Database, vUpgDict: Record<number, SQLiteVersionUpgrade>, curVersion: number, targetVersion: number): Promise<number>;
static executeStatementsProcess(mDB: Database, statements: string[]): Promise<void>;
}

8

package.json
{
"name": "jeep-sqlite",
"version": "2.5.4",
"version": "2.5.5",
"description": "Browser SQLite Stencil Component",

@@ -25,7 +25,7 @@ "main": "dist/index.cjs.js",

"dependencies": {
"@stencil/core": "^4.3.0",
"@stencil/core": "^4.9.0",
"browser-fs-access": "^0.33.0",
"jszip": "^3.10.1",
"localforage": "^1.10.0",
"sql.js": "^1.8.0"
"sql.js": "^1.9.0"
},

@@ -35,3 +35,3 @@ "devDependencies": {

"@types/node": "^16.18.11",
"@types/sql.js": "^1.4.4",
"@types/sql.js": "^1.4.9",
"jest": "^27.5.1",

@@ -38,0 +38,0 @@ "jest-cli": "^27.5.1",

dist/cjs/index-75f3d9d3.js
dist/cjs/index-75f3d9d3.js.map
dist/esm/index-0d1f3b13.js
dist/esm/index-0d1f3b13.js.map
dist/jeep-sqlite/p-5ab03169.entry.js
dist/jeep-sqlite/p-5ab03169.entry.js.map
dist/jeep-sqlite/p-7a8ed680.js
dist/jeep-sqlite/p-7a8ed680.js.map
dist/cjs/jeep-sqlite.cjs.entry.js

Sorry, the diff of this file is too big to display

dist/cjs/jeep-sqlite.cjs.entry.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/jeep-sqlite.cjs.js.map

Sorry, the diff of this file is not supported yet

dist/collection/components/jeep-sqlite/jeep-sqlite.e2e.js.map

Sorry, the diff of this file is not supported yet

dist/collection/components/jeep-sqlite/jeep-sqlite.js

Sorry, the diff of this file is too big to display

dist/collection/components/jeep-sqlite/jeep-sqlite.js.map

Sorry, the diff of this file is not supported yet

dist/collection/components/jeep-sqlite/jeep-sqlite.spec.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/database.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-delete.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-drop.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-exportJson.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-importJson.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-json.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-sqlite.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-sqlstatement.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-store.js.map

Sorry, the diff of this file is not supported yet

dist/collection/utils/utils-upgrade.js.map

Sorry, the diff of this file is not supported yet

dist/components/jeep-sqlite.js

Sorry, the diff of this file is too big to display

dist/components/jeep-sqlite.js.map

Sorry, the diff of this file is not supported yet

dist/esm/jeep-sqlite.entry.js

Sorry, the diff of this file is too big to display

dist/esm/jeep-sqlite.entry.js.map

Sorry, the diff of this file is not supported yet

dist/esm/jeep-sqlite.js.map

Sorry, the diff of this file is not supported yet

dist/jeep-sqlite/jeep-sqlite.esm.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc