Socket
Socket
Sign inDemoInstall

@capacitor-community/sqlite

Package Overview
Dependencies
Maintainers
23
Versions
241
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@capacitor-community/sqlite - npm Package Compare versions

Comparing version 2.9.5 to 3.0.0-beta.1

android/src/main/java/com/getcapacitor/community/database/sqlite/CapacitorSQLitePlugin.java
android/src/main/java/com/getcapacitor/community/database/sqlite/RetHandler.java
android/src/main/res/.gitkeep
dist/plugin.cjs.js
dist/plugin.cjs.js.map
ios/Plugin/CapacitorSQLite.swift
ios/Plugin/CapacitorSQLitePlugin.h
ios/Plugin/CapacitorSQLitePlugin.m
ios/Plugin/CapacitorSQLitePlugin.swift

10

CHANGELOG.md

@@ -0,1 +1,11 @@

## 3.0.0-beta.1 (2021-01-23)
### Chore
- update to @capacitor/core@3.0.0-beta.1
### Added Features
- better Error handling throught try...catch
## 2.9.5 (2021-01-20) REFACTOR

@@ -2,0 +12,0 @@

130

dist/esm/definitions.d.ts

@@ -13,13 +13,13 @@ declare module '@capacitor/core' {

* @param options capConnectionOptions
* @return Promise<capSQLiteResult>
* @return Promise<void>
* @since 2.9.0 refactor
*/
createConnection(options: capConnectionOptions): Promise<capSQLiteResult>;
createConnection(options: capConnectionOptions): Promise<void>;
/**
* close a database connection
* @param options capSQLiteOptions
* @return Promise<capSQLiteResult>
* @return Promise<void>
* @since 2.9.0 refactor
*/
closeConnection(options: capSQLiteOptions): Promise<capSQLiteResult>;
closeConnection(options: capSQLiteOptions): Promise<void>;
/**

@@ -36,13 +36,13 @@ * Echo a given string

* @param options: capSQLiteOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 0.0.1
*/
open(options: capSQLiteOptions): Promise<capSQLiteResult>;
open(options: capSQLiteOptions): Promise<void>;
/**
* Close a SQLite database
* @param options: capSQLiteOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 0.0.1
*/
close(options: capSQLiteOptions): Promise<capSQLiteResult>;
close(options: capSQLiteOptions): Promise<void>;
/**

@@ -86,6 +86,6 @@ * Execute a Batch of Raw Statements as String

* @param options: capSQLiteOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 0.0.1
*/
deleteDatabase(options: capSQLiteOptions): Promise<capSQLiteResult>;
deleteDatabase(options: capSQLiteOptions): Promise<void>;
/**

@@ -122,6 +122,6 @@ * Is Json Object Valid

* @param options: capSQLiteSyncDateOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.0.1-1
*/
setSyncDate(options: capSQLiteSyncDateOptions): Promise<capSQLiteResult>;
setSyncDate(options: capSQLiteSyncDateOptions): Promise<void>;
/**

@@ -137,13 +137,13 @@ * Get the synchronization date

* @param options: capSQLiteUpgradeOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.4.2-6 iOS & Electron 2.4.2-7 Android
*/
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<capSQLiteResult>;
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<void>;
/**
* Copy databases from public/assets/databases folder to application databases folder
*
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
copyFromAssets(): Promise<capSQLiteResult>;
copyFromAssets(): Promise<void>;
}

@@ -291,6 +291,2 @@ export interface capEchoOptions {

result?: boolean;
/**
* a returned message
*/
message?: string;
}

@@ -302,6 +298,2 @@ export interface capSQLiteChanges {

changes?: Changes;
/**
* a returned message
*/
message?: string;
}

@@ -323,6 +315,2 @@ export interface Changes {

values?: any[];
/**
* a returned message
*/
message?: string;
}

@@ -334,6 +322,2 @@ export interface capSQLiteJson {

export?: JsonSQLite;
/**
* a returned message
*/
message?: string;
}

@@ -345,6 +329,2 @@ export interface capSQLiteSyncDate {

syncDate?: number;
/**
* a returned message
*/
message?: string;
}

@@ -449,6 +429,6 @@ export interface JsonSQLite {

* @param set
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<capSQLiteResult>;
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<void>;
/**

@@ -460,16 +440,16 @@ * Create a connection to a database

* @param version
* @returns Promise<SQLiteDBConnection | null>
* @returns Promise<SQLiteDBConnection>
* @since 2.9.0 refactor
*/
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection | null>;
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection>;
/**
* Retrieve an existing database connection
* @param database
* @returns Promise<capSQLiteResult>
* @returns Promise<SQLiteDBConnection>
* @since 2.9.0 refactor
*/
retrieveConnection(database: string): Promise<SQLiteDBConnection | null | undefined>;
retrieveConnection(database: string): Promise<SQLiteDBConnection>;
/**
* Retrieve all database connections
* @returns Promise<capSQLiteResult>
* @returns Promise<Map<string, SQLiteDBConnection>>
* @since 2.9.0 refactor

@@ -481,12 +461,12 @@ */

* @param database
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
closeConnection(database: string): Promise<capSQLiteResult>;
closeConnection(database: string): Promise<void>;
/**
* Close all database connections
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
closeAllConnections(): Promise<capSQLiteResult>;
closeAllConnections(): Promise<void>;
/**

@@ -508,6 +488,6 @@ * Import a database From a JSON

* Copy databases from public/assets/databases folder to application databases folder
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
copyFromAssets(): Promise<capSQLiteResult>;
copyFromAssets(): Promise<void>;
}

@@ -522,11 +502,11 @@ /**

echo(value: string): Promise<capEchoResult>;
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<capSQLiteResult>;
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection | null>;
closeConnection(database: string): Promise<capSQLiteResult>;
retrieveConnection(database: string): Promise<SQLiteDBConnection | null | undefined>;
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<void>;
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection>;
closeConnection(database: string): Promise<void>;
retrieveConnection(database: string): Promise<SQLiteDBConnection>;
retrieveAllConnections(): Promise<Map<string, SQLiteDBConnection>>;
closeAllConnections(): Promise<capSQLiteResult>;
closeAllConnections(): Promise<void>;
importFromJson(jsonstring: string): Promise<capSQLiteChanges>;
isJsonValid(jsonstring: string): Promise<capSQLiteResult>;
copyFromAssets(): Promise<capSQLiteResult>;
copyFromAssets(): Promise<void>;
}

@@ -539,3 +519,3 @@ /**

* Get SQLite DB Connection DB name
* @returns Promise<string>
* @returns string
* @since 2.9.0 refactor

@@ -546,12 +526,12 @@ */

* Open a SQLite DB Connection
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
open(): Promise<capSQLiteResult>;
open(): Promise<void>;
/**
* Close a SQLite DB Connection
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
close(): Promise<capSQLiteResult>;
close(): Promise<void>;
/**

@@ -571,3 +551,3 @@ * Execute SQLite DB Connection Statements

*/
query(statement: string, values?: Array<string>): Promise<capSQLiteValues>;
query(statement: string, values?: string[]): Promise<capSQLiteValues>;
/**

@@ -580,3 +560,3 @@ * Execute SQLite DB Connection Raw Statement

*/
run(statement: string, values?: Array<any>): Promise<capSQLiteChanges>;
run(statement: string, values?: any[]): Promise<capSQLiteChanges>;
/**

@@ -588,3 +568,3 @@ * Execute SQLite DB Connection Set

*/
executeSet(set: Array<capSQLiteSet>): Promise<capSQLiteChanges>;
executeSet(set: capSQLiteSet[]): Promise<capSQLiteChanges>;
/**

@@ -598,9 +578,9 @@ * Check if a SQLite DB Connection exists

* Delete a SQLite DB Connection
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
delete(): Promise<capSQLiteResult>;
delete(): Promise<void>;
/**
* Create a synchronization table
* @returns Promise<capSQLiteResult>
* @returns Promise<capSQLiteChanges>
* @since 2.9.0 refactor

@@ -612,6 +592,6 @@ */

* @param syncdate
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
setSyncDate(syncdate: string): Promise<capSQLiteResult>;
setSyncDate(syncdate: string): Promise<void>;
/**

@@ -639,14 +619,14 @@ * Get the synchronization date

getConnectionDBName(): string;
open(): Promise<capSQLiteResult>;
close(): Promise<capSQLiteResult>;
open(): Promise<void>;
close(): Promise<void>;
execute(statements: string): Promise<capSQLiteChanges>;
query(statement: string, values?: Array<string>): Promise<capSQLiteValues>;
run(statement: string, values?: Array<any>): Promise<capSQLiteChanges>;
executeSet(set: Array<capSQLiteSet>): Promise<capSQLiteChanges>;
query(statement: string, values?: string[]): Promise<capSQLiteValues>;
run(statement: string, values?: any[]): Promise<capSQLiteChanges>;
executeSet(set: capSQLiteSet[]): Promise<capSQLiteChanges>;
isExists(): Promise<capSQLiteResult>;
delete(): Promise<capSQLiteResult>;
delete(): Promise<void>;
createSyncTable(): Promise<capSQLiteChanges>;
setSyncDate(syncdate: string): Promise<capSQLiteResult>;
setSyncDate(syncdate: string): Promise<void>;
getSyncDate(): Promise<capSQLiteSyncDate>;
exportToJson(mode: string): Promise<capSQLiteJson>;
}

330

dist/esm/definitions.js

@@ -1,10 +0,1 @@

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
/**

@@ -18,25 +9,26 @@ * SQLiteConnection Class

}
echo(value) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.echo({ value: value });
});
async echo(value) {
return await this.sqlite.echo({ value: value });
}
addUpgradeStatement(database, fromVersion, toVersion, statement, set) {
return __awaiter(this, void 0, void 0, function* () {
let upgrade = {
fromVersion,
toVersion,
statement,
set: set ? set : [],
};
const res = yield this.sqlite.addUpgradeStatement({
async addUpgradeStatement(database, fromVersion, toVersion, statement, set) {
const upgrade = {
fromVersion,
toVersion,
statement,
set: set ? set : [],
};
try {
await this.sqlite.addUpgradeStatement({
database,
upgrade: [upgrade],
});
return res;
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
createConnection(database, encrypted, mode, version) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.createConnection({
async createConnection(database, encrypted, mode, version) {
try {
await this.sqlite.createConnection({
database,

@@ -47,64 +39,78 @@ encrypted,

});
if (res.result) {
const conn = new SQLiteDBConnection(database, this.sqlite);
this._connectionDict.set(database, conn);
return conn;
}
const conn = new SQLiteDBConnection(database, this.sqlite);
this._connectionDict.set(database, conn);
return Promise.resolve(conn);
}
catch (err) {
return Promise.reject(err);
}
}
async closeConnection(database) {
try {
await this.sqlite.closeConnection({ database });
this._connectionDict.delete(database);
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
async retrieveConnection(database) {
if (this._connectionDict.has(database)) {
const conn = this._connectionDict.get(database);
if (typeof conn != 'undefined')
return Promise.resolve(conn);
else {
return null;
return Promise.reject(`Connection ${database} is undefined`);
}
});
}
else {
return Promise.reject(`Connection ${database} does not exist`);
}
}
closeConnection(database) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.closeConnection({ database });
if (res.result) {
this._connectionDict.delete(database);
}
return res;
});
async retrieveAllConnections() {
return this._connectionDict;
}
retrieveConnection(database) {
return __awaiter(this, void 0, void 0, function* () {
const conn = this._connectionDict.has(database)
? this._connectionDict.get(database)
: null;
return conn;
});
}
retrieveAllConnections() {
return __awaiter(this, void 0, void 0, function* () {
return this._connectionDict;
});
}
closeAllConnections() {
return __awaiter(this, void 0, void 0, function* () {
const delDict = new Map();
let res;
for (let database of this._connectionDict.keys()) {
res = yield this.sqlite.closeConnection({ database });
if (!res.result)
break;
async closeAllConnections() {
const delDict = new Map();
try {
for (const database of this._connectionDict.keys()) {
await this.sqlite.closeConnection({ database });
delDict.set(database, null);
}
for (let database of delDict.keys()) {
for (const database of delDict.keys()) {
this._connectionDict.delete(database);
}
return res;
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
importFromJson(jsonstring) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.importFromJson({ jsonstring: jsonstring });
});
async importFromJson(jsonstring) {
try {
const ret = await this.sqlite.importFromJson({ jsonstring: jsonstring });
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(err);
}
}
isJsonValid(jsonstring) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.isJsonValid({ jsonstring: jsonstring });
});
async isJsonValid(jsonstring) {
try {
const ret = await this.sqlite.isJsonValid({ jsonstring: jsonstring });
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(err);
}
}
copyFromAssets() {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.copyFromAssets();
});
async copyFromAssets() {
try {
await this.sqlite.copyFromAssets();
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}

@@ -124,29 +130,38 @@ }

}
open() {
return __awaiter(this, void 0, void 0, function* () {
console.log('>>> in SQLiteDBConnection open dbName ' + this.dbName);
const res = yield this.sqlite.open({ database: this.dbName });
return res;
});
async open() {
console.log('>>> in SQLiteDBConnection open dbName ' + this.dbName);
try {
await this.sqlite.open({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
close() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.close({ database: this.dbName });
return res;
});
async close() {
try {
await this.sqlite.close({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
execute(statements) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.execute({
async execute(statements) {
try {
const res = await this.sqlite.execute({
database: this.dbName,
statements: statements,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
query(statement, values) {
return __awaiter(this, void 0, void 0, function* () {
let res;
async query(statement, values) {
let res;
try {
if (values && values.length > 0) {
res = yield this.sqlite.query({
res = await this.sqlite.query({
database: this.dbName,

@@ -158,3 +173,3 @@ statement: statement,

else {
res = yield this.sqlite.query({
res = await this.sqlite.query({
database: this.dbName,

@@ -165,10 +180,13 @@ statement: statement,

}
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
run(statement, values) {
return __awaiter(this, void 0, void 0, function* () {
let res;
async run(statement, values) {
let res;
try {
if (values && values.length > 0) {
res = yield this.sqlite.run({
res = await this.sqlite.run({
database: this.dbName,

@@ -180,3 +198,3 @@ statement: statement,

else {
res = yield this.sqlite.run({
res = await this.sqlite.run({
database: this.dbName,

@@ -187,65 +205,87 @@ statement: statement,

}
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
executeSet(set) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.executeSet({
async executeSet(set) {
try {
const res = await this.sqlite.executeSet({
database: this.dbName,
set: set,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
isExists() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.isDBExists({
async isExists() {
try {
const res = await this.sqlite.isDBExists({
database: this.dbName,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
delete() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.deleteDatabase({
database: this.dbName,
});
return res;
});
async delete() {
try {
await this.sqlite.deleteDatabase({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
createSyncTable() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.createSyncTable({
async createSyncTable() {
try {
const res = await this.sqlite.createSyncTable({
database: this.dbName,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
setSyncDate(syncdate) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.setSyncDate({
async setSyncDate(syncdate) {
try {
await this.sqlite.setSyncDate({
database: this.dbName,
syncdate: syncdate,
});
return res;
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
getSyncDate() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.getSyncDate({
async getSyncDate() {
try {
const res = await this.sqlite.getSyncDate({
database: this.dbName,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
exportToJson(mode) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.exportToJson({
async exportToJson(mode) {
try {
const res = await this.sqlite.exportToJson({
database: this.dbName,
jsonexportmode: mode,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
}
//# sourceMappingURL=definitions.js.map

4

dist/esm/index.d.ts

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

import type { CapacitorSQLitePlugin } from './definitions';
declare const CapacitorSQLite: CapacitorSQLitePlugin;
export { CapacitorSQLite };
export * from './definitions';
export * from './web';

6

dist/esm/index.js

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

import { registerPlugin } from '@capacitor/core';
const CapacitorSQLite = registerPlugin('CapacitorSQLite', {
web: () => import('./web').then(m => new m.CapacitorSQLiteWeb()),
});
export { CapacitorSQLite };
export * from './definitions';
export * from './web';
//# sourceMappingURL=index.js.map

20

dist/esm/web.d.ts
import { WebPlugin } from '@capacitor/core';
import { CapacitorSQLitePlugin, capEchoOptions, capSQLiteOptions, capSQLiteExecuteOptions, capSQLiteSetOptions, capSQLiteRunOptions, capSQLiteQueryOptions, capSQLiteImportOptions, capSQLiteExportOptions, capSQLiteSyncDateOptions, capEchoResult, capSQLiteResult, capSQLiteChanges, capSQLiteValues, capSQLiteJson, capSQLiteUpgradeOptions, capSQLiteSyncDate } from './definitions';
import type { CapacitorSQLitePlugin, capEchoOptions, capSQLiteOptions, capSQLiteExecuteOptions, capSQLiteSetOptions, capSQLiteRunOptions, capSQLiteQueryOptions, capSQLiteImportOptions, capSQLiteExportOptions, capSQLiteSyncDateOptions, capEchoResult, capSQLiteResult, capSQLiteChanges, capSQLiteValues, capSQLiteJson, capSQLiteUpgradeOptions, capSQLiteSyncDate } from './definitions';
export declare class CapacitorSQLiteWeb extends WebPlugin implements CapacitorSQLitePlugin {
constructor();
echo(options: capEchoOptions): Promise<capEchoResult>;
createConnection(options: capSQLiteOptions): Promise<capSQLiteResult>;
open(options: capSQLiteOptions): Promise<capSQLiteResult>;
closeConnection(options: capSQLiteOptions): Promise<capSQLiteResult>;
close(options: capSQLiteOptions): Promise<capSQLiteResult>;
createConnection(options: capSQLiteOptions): Promise<void>;
open(options: capSQLiteOptions): Promise<void>;
closeConnection(options: capSQLiteOptions): Promise<void>;
close(options: capSQLiteOptions): Promise<void>;
execute(options: capSQLiteExecuteOptions): Promise<capSQLiteChanges>;

@@ -15,3 +15,3 @@ executeSet(options: capSQLiteSetOptions): Promise<capSQLiteChanges>;

isDBExists(options: capSQLiteOptions): Promise<capSQLiteResult>;
deleteDatabase(options: capSQLiteOptions): Promise<capSQLiteResult>;
deleteDatabase(options: capSQLiteOptions): Promise<void>;
isJsonValid(options: capSQLiteImportOptions): Promise<capSQLiteResult>;

@@ -21,8 +21,6 @@ importFromJson(options: capSQLiteImportOptions): Promise<capSQLiteChanges>;

createSyncTable(options: capSQLiteOptions): Promise<capSQLiteChanges>;
setSyncDate(options: capSQLiteSyncDateOptions): Promise<capSQLiteResult>;
setSyncDate(options: capSQLiteSyncDateOptions): Promise<void>;
getSyncDate(options: capSQLiteOptions): Promise<capSQLiteSyncDate>;
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<capSQLiteResult>;
copyFromAssets(): Promise<capSQLiteResult>;
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<void>;
copyFromAssets(): Promise<void>;
}
declare const CapacitorSQLite: CapacitorSQLiteWeb;
export { CapacitorSQLite };

218

dist/esm/web.js

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

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
import { WebPlugin } from '@capacitor/core';
//1234567890123456789012345678901234567890123456789012345678901234567890
export class CapacitorSQLiteWeb extends WebPlugin {

@@ -19,173 +9,79 @@ constructor() {

}
echo(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('ECHO in Web plugin', options);
return options;
});
async echo(options) {
console.log('ECHO in Web plugin', options);
return options;
}
createConnection(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('createConnection', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async createConnection(options) {
console.log('createConnection', options);
throw this.unimplemented('Not implemented on web.');
}
open(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('open', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async open(options) {
console.log('open', options);
throw this.unimplemented('Not implemented on web.');
}
closeConnection(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('closeConnection', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async closeConnection(options) {
console.log('closeConnection', options);
throw this.unimplemented('Not implemented on web.');
}
close(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('close', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async close(options) {
console.log('close', options);
throw this.unimplemented('Not implemented on web.');
}
execute(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('execute', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async execute(options) {
console.log('execute', options);
throw this.unimplemented('Not implemented on web.');
}
executeSet(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('execute', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async executeSet(options) {
console.log('execute', options);
throw this.unimplemented('Not implemented on web.');
}
run(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('run', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async run(options) {
console.log('run', options);
throw this.unimplemented('Not implemented on web.');
}
query(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('query', options);
return Promise.resolve({
values: [],
message: `Not implemented on Web Platform`,
});
});
async query(options) {
console.log('query', options);
throw this.unimplemented('Not implemented on web.');
}
isDBExists(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('in Web isDBExists', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async isDBExists(options) {
console.log('in Web isDBExists', options);
throw this.unimplemented('Not implemented on web.');
}
deleteDatabase(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('deleteDatabase', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async deleteDatabase(options) {
console.log('deleteDatabase', options);
throw this.unimplemented('Not implemented on web.');
}
isJsonValid(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('isJsonValid', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async isJsonValid(options) {
console.log('isJsonValid', options);
throw this.unimplemented('Not implemented on web.');
}
importFromJson(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('importFromJson', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async importFromJson(options) {
console.log('importFromJson', options);
throw this.unimplemented('Not implemented on web.');
}
exportToJson(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('exportToJson', options);
return Promise.resolve({
message: `Not implemented on Web Platform`,
});
});
async exportToJson(options) {
console.log('exportToJson', options);
throw this.unimplemented('Not implemented on web.');
}
createSyncTable(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('createSyncTable', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async createSyncTable(options) {
console.log('createSyncTable', options);
throw this.unimplemented('Not implemented on web.');
}
setSyncDate(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('setSyncDate', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async setSyncDate(options) {
console.log('setSyncDate', options);
throw this.unimplemented('Not implemented on web.');
}
getSyncDate(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('getSyncDate', options);
return Promise.resolve({
syncDate: 0,
message: `Not implemented on Web Platform`,
});
});
async getSyncDate(options) {
console.log('getSyncDate', options);
throw this.unimplemented('Not implemented on web.');
}
addUpgradeStatement(options) {
return __awaiter(this, void 0, void 0, function* () {
console.log('addUpgradeStatement', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async addUpgradeStatement(options) {
console.log('addUpgradeStatement', options);
throw this.unimplemented('Not implemented on web.');
}
copyFromAssets() {
return __awaiter(this, void 0, void 0, function* () {
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async copyFromAssets() {
console.log('copyFromAssets');
throw this.unimplemented('Not implemented on web.');
}
}
const CapacitorSQLite = new CapacitorSQLiteWeb();
export { CapacitorSQLite };
import { registerWebPlugin } from '@capacitor/core';
registerWebPlugin(CapacitorSQLite);
//# sourceMappingURL=web.js.map

558

dist/plugin.js

@@ -1,13 +0,4 @@

var capacitorPlugin = (function (exports, core) {
var capacitorCapacitorSQLite = (function (exports, core) {
'use strict';
var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
/**

@@ -21,25 +12,26 @@ * SQLiteConnection Class

}
echo(value) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.echo({ value: value });
});
async echo(value) {
return await this.sqlite.echo({ value: value });
}
addUpgradeStatement(database, fromVersion, toVersion, statement, set) {
return __awaiter(this, void 0, void 0, function* () {
let upgrade = {
fromVersion,
toVersion,
statement,
set: set ? set : [],
};
const res = yield this.sqlite.addUpgradeStatement({
async addUpgradeStatement(database, fromVersion, toVersion, statement, set) {
const upgrade = {
fromVersion,
toVersion,
statement,
set: set ? set : [],
};
try {
await this.sqlite.addUpgradeStatement({
database,
upgrade: [upgrade],
});
return res;
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
createConnection(database, encrypted, mode, version) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.createConnection({
async createConnection(database, encrypted, mode, version) {
try {
await this.sqlite.createConnection({
database,

@@ -50,64 +42,78 @@ encrypted,

});
if (res.result) {
const conn = new SQLiteDBConnection(database, this.sqlite);
this._connectionDict.set(database, conn);
return conn;
}
const conn = new SQLiteDBConnection(database, this.sqlite);
this._connectionDict.set(database, conn);
return Promise.resolve(conn);
}
catch (err) {
return Promise.reject(err);
}
}
async closeConnection(database) {
try {
await this.sqlite.closeConnection({ database });
this._connectionDict.delete(database);
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
async retrieveConnection(database) {
if (this._connectionDict.has(database)) {
const conn = this._connectionDict.get(database);
if (typeof conn != 'undefined')
return Promise.resolve(conn);
else {
return null;
return Promise.reject(`Connection ${database} is undefined`);
}
});
}
else {
return Promise.reject(`Connection ${database} does not exist`);
}
}
closeConnection(database) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.closeConnection({ database });
if (res.result) {
this._connectionDict.delete(database);
}
return res;
});
async retrieveAllConnections() {
return this._connectionDict;
}
retrieveConnection(database) {
return __awaiter(this, void 0, void 0, function* () {
const conn = this._connectionDict.has(database)
? this._connectionDict.get(database)
: null;
return conn;
});
}
retrieveAllConnections() {
return __awaiter(this, void 0, void 0, function* () {
return this._connectionDict;
});
}
closeAllConnections() {
return __awaiter(this, void 0, void 0, function* () {
const delDict = new Map();
let res;
for (let database of this._connectionDict.keys()) {
res = yield this.sqlite.closeConnection({ database });
if (!res.result)
break;
async closeAllConnections() {
const delDict = new Map();
try {
for (const database of this._connectionDict.keys()) {
await this.sqlite.closeConnection({ database });
delDict.set(database, null);
}
for (let database of delDict.keys()) {
for (const database of delDict.keys()) {
this._connectionDict.delete(database);
}
return res;
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
importFromJson(jsonstring) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.importFromJson({ jsonstring: jsonstring });
});
async importFromJson(jsonstring) {
try {
const ret = await this.sqlite.importFromJson({ jsonstring: jsonstring });
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(err);
}
}
isJsonValid(jsonstring) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.isJsonValid({ jsonstring: jsonstring });
});
async isJsonValid(jsonstring) {
try {
const ret = await this.sqlite.isJsonValid({ jsonstring: jsonstring });
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(err);
}
}
copyFromAssets() {
return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.copyFromAssets();
});
async copyFromAssets() {
try {
await this.sqlite.copyFromAssets();
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}

@@ -127,29 +133,38 @@ }

}
open() {
return __awaiter(this, void 0, void 0, function* () {
console.log('>>> in SQLiteDBConnection open dbName ' + this.dbName);
const res = yield this.sqlite.open({ database: this.dbName });
return res;
});
async open() {
console.log('>>> in SQLiteDBConnection open dbName ' + this.dbName);
try {
await this.sqlite.open({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
close() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.close({ database: this.dbName });
return res;
});
async close() {
try {
await this.sqlite.close({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
execute(statements) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.execute({
async execute(statements) {
try {
const res = await this.sqlite.execute({
database: this.dbName,
statements: statements,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
query(statement, values) {
return __awaiter(this, void 0, void 0, function* () {
let res;
async query(statement, values) {
let res;
try {
if (values && values.length > 0) {
res = yield this.sqlite.query({
res = await this.sqlite.query({
database: this.dbName,

@@ -161,3 +176,3 @@ statement: statement,

else {
res = yield this.sqlite.query({
res = await this.sqlite.query({
database: this.dbName,

@@ -168,10 +183,13 @@ statement: statement,

}
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
run(statement, values) {
return __awaiter(this, void 0, void 0, function* () {
let res;
async run(statement, values) {
let res;
try {
if (values && values.length > 0) {
res = yield this.sqlite.run({
res = await this.sqlite.run({
database: this.dbName,

@@ -183,3 +201,3 @@ statement: statement,

else {
res = yield this.sqlite.run({
res = await this.sqlite.run({
database: this.dbName,

@@ -190,76 +208,92 @@ statement: statement,

}
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
executeSet(set) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.executeSet({
async executeSet(set) {
try {
const res = await this.sqlite.executeSet({
database: this.dbName,
set: set,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
isExists() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.isDBExists({
async isExists() {
try {
const res = await this.sqlite.isDBExists({
database: this.dbName,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
delete() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.deleteDatabase({
database: this.dbName,
});
return res;
});
async delete() {
try {
await this.sqlite.deleteDatabase({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
createSyncTable() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.createSyncTable({
async createSyncTable() {
try {
const res = await this.sqlite.createSyncTable({
database: this.dbName,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
setSyncDate(syncdate) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.setSyncDate({
async setSyncDate(syncdate) {
try {
await this.sqlite.setSyncDate({
database: this.dbName,
syncdate: syncdate,
});
return res;
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
}
getSyncDate() {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.getSyncDate({
async getSyncDate() {
try {
const res = await this.sqlite.getSyncDate({
database: this.dbName,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
exportToJson(mode) {
return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.exportToJson({
async exportToJson(mode) {
try {
const res = await this.sqlite.exportToJson({
database: this.dbName,
jsonexportmode: mode,
});
return res;
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
}
}
var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
//1234567890123456789012345678901234567890123456789012345678901234567890
const CapacitorSQLite = core.registerPlugin('CapacitorSQLite', {
web: () => Promise.resolve().then(function () { return web; }).then(m => new m.CapacitorSQLiteWeb()),
});
class CapacitorSQLiteWeb extends core.WebPlugin {

@@ -272,174 +306,86 @@ constructor() {

}
echo(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('ECHO in Web plugin', options);
return options;
});
async echo(options) {
console.log('ECHO in Web plugin', options);
return options;
}
createConnection(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('createConnection', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async createConnection(options) {
console.log('createConnection', options);
throw this.unimplemented('Not implemented on web.');
}
open(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('open', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async open(options) {
console.log('open', options);
throw this.unimplemented('Not implemented on web.');
}
closeConnection(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('closeConnection', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async closeConnection(options) {
console.log('closeConnection', options);
throw this.unimplemented('Not implemented on web.');
}
close(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('close', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async close(options) {
console.log('close', options);
throw this.unimplemented('Not implemented on web.');
}
execute(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('execute', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async execute(options) {
console.log('execute', options);
throw this.unimplemented('Not implemented on web.');
}
executeSet(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('execute', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async executeSet(options) {
console.log('execute', options);
throw this.unimplemented('Not implemented on web.');
}
run(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('run', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async run(options) {
console.log('run', options);
throw this.unimplemented('Not implemented on web.');
}
query(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('query', options);
return Promise.resolve({
values: [],
message: `Not implemented on Web Platform`,
});
});
async query(options) {
console.log('query', options);
throw this.unimplemented('Not implemented on web.');
}
isDBExists(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('in Web isDBExists', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async isDBExists(options) {
console.log('in Web isDBExists', options);
throw this.unimplemented('Not implemented on web.');
}
deleteDatabase(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('deleteDatabase', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async deleteDatabase(options) {
console.log('deleteDatabase', options);
throw this.unimplemented('Not implemented on web.');
}
isJsonValid(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('isJsonValid', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async isJsonValid(options) {
console.log('isJsonValid', options);
throw this.unimplemented('Not implemented on web.');
}
importFromJson(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('importFromJson', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async importFromJson(options) {
console.log('importFromJson', options);
throw this.unimplemented('Not implemented on web.');
}
exportToJson(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('exportToJson', options);
return Promise.resolve({
message: `Not implemented on Web Platform`,
});
});
async exportToJson(options) {
console.log('exportToJson', options);
throw this.unimplemented('Not implemented on web.');
}
createSyncTable(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('createSyncTable', options);
return Promise.resolve({
changes: { changes: -1 },
message: `Not implemented on Web Platform`,
});
});
async createSyncTable(options) {
console.log('createSyncTable', options);
throw this.unimplemented('Not implemented on web.');
}
setSyncDate(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('setSyncDate', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async setSyncDate(options) {
console.log('setSyncDate', options);
throw this.unimplemented('Not implemented on web.');
}
getSyncDate(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('getSyncDate', options);
return Promise.resolve({
syncDate: 0,
message: `Not implemented on Web Platform`,
});
});
async getSyncDate(options) {
console.log('getSyncDate', options);
throw this.unimplemented('Not implemented on web.');
}
addUpgradeStatement(options) {
return __awaiter$1(this, void 0, void 0, function* () {
console.log('addUpgradeStatement', options);
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async addUpgradeStatement(options) {
console.log('addUpgradeStatement', options);
throw this.unimplemented('Not implemented on web.');
}
copyFromAssets() {
return __awaiter$1(this, void 0, void 0, function* () {
return Promise.resolve({
result: false,
message: `Not implemented on Web Platform`,
});
});
async copyFromAssets() {
console.log('copyFromAssets');
throw this.unimplemented('Not implemented on web.');
}
}
const CapacitorSQLite = new CapacitorSQLiteWeb();
core.registerWebPlugin(CapacitorSQLite);
var web = /*#__PURE__*/Object.freeze({
__proto__: null,
CapacitorSQLiteWeb: CapacitorSQLiteWeb
});
exports.CapacitorSQLite = CapacitorSQLite;
exports.CapacitorSQLiteWeb = CapacitorSQLiteWeb;
exports.SQLiteConnection = SQLiteConnection;

@@ -446,0 +392,0 @@ exports.SQLiteDBConnection = SQLiteDBConnection;

6

electron/dist/esm/electron/src/electron-utils/Database.d.ts

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

import { capSQLiteVersionUpgrade, JsonSQLite } from '../definitions';
import type { capSQLiteVersionUpgrade, JsonSQLite } from '../definitions';
export declare class Database {

@@ -50,5 +50,5 @@ private _isDBOpen;

* create the synchronization table
* @returns Promise<{result: boolean, message: string}>
* @returns Promise<number>
*/
createSyncTable(): Promise<any>;
createSyncTable(): Promise<number>;
/**

@@ -55,0 +55,0 @@ * SetSyncDate

392

electron/dist/esm/electron/src/electron-utils/Database.js
import { __awaiter } from "tslib";
import { GlobalSQLite } from '../GlobalSQLite';
import { ExportToJson } from './ImportExportJson/exportToJson';
import { ImportFromJson } from './ImportExportJson/importFromJson';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { UtilsEncryption } from './utilsEncryption';
import { UtilsFile } from './utilsFile';
import { UtilsSQLite } from './utilsSQLite';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { GlobalSQLite } from '../GlobalSQLite';
import { UtilsEncryption } from './utilsEncryption';
import { UtilsUpgrade } from './utilsUpgrade';
import { ImportFromJson } from './ImportExportJson/importFromJson';
import { ExportToJson } from './ImportExportJson/exportToJson';
//1234567890123456789012345678901234567890123456789012345678901234567890
export class Database {

@@ -50,48 +49,46 @@ constructor(dbName, encrypted, mode, version, upgDict) {

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
this._isDBOpen = false;
let password = '';
try {
if (this._encrypted &&
(this._mode === 'secret' || this._mode === 'encryption')) {
password = this._uGlobal.secret;
this._isDBOpen = false;
let password = '';
try {
if (this._encrypted &&
(this._mode === 'secret' || this._mode === 'encryption')) {
password = this._uGlobal.secret;
}
if (this._mode === 'newsecret') {
// change the password
const oPassword = this._uGlobal.secret;
const nPassword = this._uGlobal.newsecret;
yield this._uSQLite.changePassword(this._pathDB, oPassword, nPassword);
password = nPassword;
}
if (this._mode === 'encryption') {
yield this._uEncrypt.encryptDatabase(this._pathDB, password);
}
this._mDB = yield this._uSQLite.openOrCreateDatabase(this._pathDB, password);
const curVersion = yield this._uSQLite.getVersion(this._mDB);
this._isDBOpen = true;
if (this._version > curVersion) {
try {
// execute the upgrade flow process
yield this._uUpg.onUpgrade(this._mDB, this._vUpgDict, this._dbName, curVersion, this._version);
// delete the backup database
yield this._uFile.deleteFileName(`backup-${this._dbName}`);
}
if (this._mode === 'newsecret') {
// change the password
const oPassword = this._uGlobal.secret;
const nPassword = this._uGlobal.newsecret;
yield this._uSQLite.changePassword(this._pathDB, oPassword, nPassword);
password = nPassword;
}
if (this._mode === 'encryption') {
yield this._uEncrypt.encryptDatabase(this._pathDB, password);
}
this._mDB = yield this._uSQLite.openOrCreateDatabase(this._pathDB, password);
let curVersion = yield this._uSQLite.getVersion(this._mDB);
this._isDBOpen = true;
if (this._version > curVersion) {
catch (err) {
// restore the database from backup
try {
// execute the upgrade flow process
yield this._uUpg.onUpgrade(this._mDB, this._vUpgDict, this._dbName, curVersion, this._version);
// delete the backup database
yield this._uFile.deleteFileName(`backup-${this._dbName}`);
yield this._uFile.restoreFileName(this._dbName, 'backup');
}
catch (err) {
// restore the database from backup
try {
yield this._uFile.restoreFileName(this._dbName, 'backup');
}
catch (err) {
reject(new Error(`Open: ${err.message}`));
}
return Promise.reject(new Error(`Open: ${err.message}`));
}
}
resolve();
}
catch (err) {
if (this._isDBOpen)
this.close();
reject(new Error(`Open: ${err.message}`));
}
}));
return Promise.resolve();
}
catch (err) {
if (this._isDBOpen)
this.close();
return Promise.reject(new Error(`Open: ${err.message}`));
}
});

@@ -106,16 +103,14 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
if (this._mDB != null && this._isDBOpen) {
this._mDB.close((err) => {
if (err) {
let msg = 'Close: Failed in closing: ';
msg += `${this._dbName} ${err.message}`;
reject(new Error(msg));
}
this._isDBOpen = false;
resolve();
});
}
resolve();
}));
if (this._mDB != null && this._isDBOpen) {
this._mDB.close((err) => {
if (err) {
let msg = 'Close: Failed in closing: ';
msg += `${this._dbName} ${err.message}`;
return Promise.reject(new Error(msg));
}
this._isDBOpen = false;
return Promise.resolve();
});
}
return Promise.resolve();
});

@@ -131,34 +126,32 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
// test if file exists
const isExists = this._uFile.isFileExists(dbName);
if (isExists && !this._isDBOpen) {
// open the database
try {
yield this.open();
}
catch (err) {
reject(new Error(`DeleteDB: ${err.message}`));
}
// test if file exists
const isExists = this._uFile.isFileExists(dbName);
if (isExists && !this._isDBOpen) {
// open the database
try {
yield this.open();
}
// close the database
catch (err) {
return Promise.reject(new Error(`DeleteDB: ${err.message}`));
}
}
// close the database
try {
yield this.close();
}
catch (err) {
return Promise.reject(new Error('DeleteDB: Close failed'));
}
// delete the database
if (isExists) {
try {
yield this.close();
yield this._uFile.deleteFileName(dbName);
}
catch (err) {
reject(new Error('DeleteDB: Close failed'));
let msg = `DeleteDB: deleteFile ${dbName}`;
msg += ` failed ${err.message}`;
return Promise.reject(new Error(msg));
}
// delete the database
if (isExists) {
try {
yield this._uFile.deleteFileName(dbName);
}
catch (err) {
let msg = `DeleteDB: deleteFile ${dbName}`;
msg += ` failed ${err.message}`;
reject(new Error(msg));
}
}
resolve();
}));
}
return Promise.resolve();
});

@@ -169,3 +162,3 @@ }

* create the synchronization table
* @returns Promise<{result: boolean, message: string}>
* @returns Promise<number>
*/

@@ -177,6 +170,6 @@ createSyncTable() {

msg += `not opened`;
return { result: false, message: msg };
return Promise.reject(new Error(msg));
}
let changes = -1;
let isOpen = this._isDBOpen;
const isOpen = this._isDBOpen;
// check if the table has already being created

@@ -196,9 +189,9 @@ try {

if (changes < 0) {
return { changes: -1, message: `CreateSyncTable failed` };
return Promise.reject(new Error(`CreateSyncTable: failed changes < 0`));
}
}
return { changes: changes };
return Promise.resolve(changes);
}
catch (err) {
return { changes: -1, message: `CreateSyncTable: ${err.message}` };
return Promise.reject(new Error(`CreateSyncTable: ${err.message}`));
}

@@ -273,28 +266,26 @@ });

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
if (!this._isDBOpen) {
let msg = `ExecuteSQL: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
if (!this._isDBOpen) {
let msg = `ExecuteSQL: Database ${this._dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
yield this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
const changes = yield this._uSQLite.execute(this._mDB, sql);
if (changes < 0) {
return Promise.reject(new Error('ExecuteSQL: changes < 0'));
}
yield this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
return Promise.resolve(changes);
}
catch (err) {
let msg = `ExecuteSQL: ${err.message}`;
try {
yield this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
const changes = yield this._uSQLite.execute(this._mDB, sql);
if (changes < 0) {
reject(new Error('ExecuteSQL: changes < 0'));
}
yield this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
resolve(changes);
yield this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
let msg = `ExecuteSQL: ${err.message}`;
try {
yield this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
msg += ` : ${err.message}`;
}
reject(new Error(`ExecuteSQL: ${msg}`));
msg += ` : ${err.message}`;
}
}));
return Promise.reject(new Error(`ExecuteSQL: ${msg}`));
}
});

@@ -311,16 +302,14 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
if (!this._isDBOpen) {
let msg = `SelectSQL: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
}
try {
const retArr = yield this._uSQLite.queryAll(this._mDB, sql, values);
resolve(retArr);
}
catch (err) {
reject(new Error(`SelectSQL: ${err.message}`));
}
}));
if (!this._isDBOpen) {
let msg = `SelectSQL: Database ${this._dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
const retArr = yield this._uSQLite.queryAll(this._mDB, sql, values);
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`SelectSQL: ${err.message}`));
}
});

@@ -337,42 +326,40 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
if (!this._isDBOpen) {
let msg = `RunSQL: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
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 = yield this._uSQLite.dbChanges(this._mDB);
// start a transaction
yield this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
return Promise.reject(new Error(`RunSQL: ${err.message}`));
}
this._mDB.run(statement, values, (err) => __awaiter(this, void 0, void 0, function* () {
if (err) {
const msg = err.message;
try {
yield this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
return Promise.reject(new Error(`RunSQL: ${err.message}`));
}
catch (err) {
return Promise.reject(new Error(`RunSQL: ${msg}: ` + `${err.message}`));
}
}
let retRes = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
initChanges = yield this._uSQLite.dbChanges(this._mDB);
// start a transaction
yield this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
reject(new Error(`RunSQL: ${err.message}`));
}
this._mDB.run(statement, values, (err) => __awaiter(this, void 0, void 0, function* () {
if (err) {
const msg = err.message;
try {
yield this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
reject(new Error(`RunSQL: ${err.message}`));
}
catch (err) {
reject(new Error(`RunSQL: ${msg}: ` + `${err.message}`));
}
else {
try {
yield this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes =
(yield this._uSQLite.dbChanges(this._mDB)) - initChanges;
retRes.lastId = yield this._uSQLite.getLastId(this._mDB);
return Promise.resolve(retRes);
}
else {
try {
yield this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes =
(yield this._uSQLite.dbChanges(this._mDB)) - initChanges;
retRes.lastId = yield this._uSQLite.getLastId(this._mDB);
resolve(retRes);
}
catch (err) {
reject(new Error(`RunSQL: ${err.message}`));
}
catch (err) {
return Promise.reject(new Error(`RunSQL: ${err.message}`));
}
}));
}
}));

@@ -389,39 +376,36 @@ });

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
if (!this._isDBOpen) {
let msg = `ExecSet: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
}
let retRes = { changes: -1, lastId: -1 };
let initChanges = -1;
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 = yield this._uSQLite.dbChanges(this._mDB);
// start a transaction
yield this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
return Promise.reject(new Error(`ExecSet: ${err.message}`));
}
try {
retRes.lastId = yield this._uSQLite.executeSet(this._mDB, set);
yield this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes = (yield this._uSQLite.dbChanges(this._mDB)) - initChanges;
return Promise.resolve(retRes);
}
catch (err) {
const msg = err.message;
try {
initChanges = yield this._uSQLite.dbChanges(this._mDB);
// start a transaction
yield this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
yield this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
reject(new Error(`ExecSet: ${err.message}`));
return Promise.reject(new Error(`ExecSet: ${msg}: ` + `${err.message}`));
}
try {
retRes.lastId = yield this._uSQLite.executeSet(this._mDB, set);
yield this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes =
(yield this._uSQLite.dbChanges(this._mDB)) - initChanges;
resolve(retRes);
}
catch (err) {
const msg = err.message;
try {
yield this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
}
catch (err) {
reject(new Error(`ExecSet: ${msg}: ` + `${err.message}`));
}
}
}));
}
});
}
importJson(jsonData) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let changes = -1;

@@ -436,15 +420,15 @@ if (this._isDBOpen) {

}
resolve(changes);
return Promise.resolve(changes);
}
catch (err) {
reject(new Error(`ImportJson: ${err.message}`));
return Promise.reject(new Error(`ImportJson: ${err.message}`));
}
}
else {
reject(new Error(`ImportJson: database is closed`));
return Promise.reject(new Error(`ImportJson: database is closed`));
}
}));
});
}
exportJson(mode) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const inJson = {};

@@ -460,18 +444,18 @@ inJson.database = this._dbName.slice(0, -9);

if (isValid) {
resolve(retJson);
return Promise.resolve(retJson);
}
else {
reject(new Error(`ExportJson: retJson not valid`));
return Promise.reject(new Error(`ExportJson: retJson not valid`));
}
}
catch (err) {
reject(new Error(`ExportJson: ${err.message}`));
return Promise.reject(new Error(`ExportJson: ${err.message}`));
}
}
else {
reject(new Error(`ExportJson: database is closed`));
return Promise.reject(new Error(`ExportJson: database is closed`));
}
}));
});
}
}
//# sourceMappingURL=Database.js.map

2

electron/dist/esm/electron/src/electron-utils/ImportExportJson/exportToJson.d.ts

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

import { JsonSQLite } from '../../definitions';
import type { JsonSQLite } from '../../definitions';
export declare class ExportToJson {

@@ -3,0 +3,0 @@ private _uSQLite;

789

electron/dist/esm/electron/src/electron-utils/ImportExportJson/exportToJson.js

@@ -8,117 +8,2 @@ import { __awaiter } from "tslib";

this._uJson = new UtilsJson();
/*
private async createJsonTable(
mDB: any,
nTable: any,
mode: string,
modTables: any,
): Promise<JsonTable> {
return new Promise(async (resolve, reject) => {
let table: JsonTable = {} as JsonTable;
// let isSchema: boolean = false;
// let isIndexes: boolean = false;
// let isTriggers: boolean = false;
// let isValues: boolean = false;
table.name = nTable.name;
try {
if (
mode === 'full' ||
(mode === 'partial' && modTables[table.name] === 'Create')
) {
// create JsonSchema
const schema: JsonColumn[] = await this.createJsonTableSchema(nTable);
table.schema = schema;
// isSchema = true;
// create JsonIndexes
const indexes: JsonIndex[] = await this.createJsonTableIndexes(
mDB,
nTable,
);
table.indexes = indexes;
// isIndexes = true;
// create Triggers
}
resolve(table);
} catch (err) {
reject(new Error(`CreateJsonTable: ${err.message}`));
}
});
}
private async createJsonTableSchema(table: any): Promise<JsonColumn[]> {
return new Promise(async (resolve, reject) => {
try {
let schema: Array<JsonColumn> = [];
// take the substring between parenthesis
let openPar: number = table.sql.indexOf('(');
let closePar: number = table.sql.lastIndexOf(')');
let sstr: String = table.sql.substring(openPar + 1, closePar);
let isStrfTime: boolean = false;
if (sstr.includes('strftime')) isStrfTime = true;
let sch: Array<string> = sstr.replace(/\n/g, '').split(',');
if (isStrfTime) {
let nSch: string[] = [];
for (let j: number = 0; j < sch.length; j++) {
if (sch[j].includes('strftime')) {
nSch.push(sch[j] + ',' + sch[j + 1]);
j++;
} else {
nSch.push(sch[j]);
}
}
sch = [...nSch];
}
for (let j: number = 0; j < sch.length; j++) {
const rstr = sch[j].trim();
let idx = rstr.indexOf(' ');
//find the index of the first
let row: Array<string> = [rstr.slice(0, idx), rstr.slice(idx + 1)];
if (row.length != 2) {
reject(
new Error(
'CreateJsonTableSchema: ' + 'failed in returning sql statement',
),
);
}
if (row[0].toUpperCase() != 'FOREIGN') {
schema.push({ column: row[0], value: row[1] });
} else {
const oPar: number = rstr.indexOf('(');
const cPar: number = rstr.indexOf(')');
row = [rstr.slice(oPar + 1, cPar), rstr.slice(cPar + 2)];
if (row.length != 2) {
reject(
new Error(
'CreateJsonTableSchema: ' +
'failed in returning sql FOREIGN statement',
),
);
}
schema.push({ foreignkey: row[0], value: row[1] });
}
}
console.log('schema ' + JSON.stringify(schema));
resolve(schema);
} catch (err) {
reject(new Error(`CreateJsonTableSchema: ${err.message}`));
}
});
}
private async createJsonTableIndexes(
mDB: any,
table: any,
): Promise<JsonIndex[]> {
return new Promise(async (resolve, reject) => {
try {
let indexes: JsonIndex[] = [];
console.log('mDB ' + JSON.stringify(mDB));
console.log('table ' + JSON.stringify(table));
resolve(indexes);
} catch (err) {
reject(new Error(`CreateJsonTableIndexes: ${err.message}`));
}
});
}
*/
}

@@ -131,10 +16,11 @@ /**

createExportObject(mDB, sqlObj) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let retObj = {};
return __awaiter(this, void 0, void 0, function* () {
const retObj = {};
let tables = [];
let errmsg = '';
try {
// get Table's name
let resTables = yield this.getTablesNameSQL(mDB);
const resTables = yield this.getTablesNameSQL(mDB);
if (resTables.length === 0) {
reject(new Error("createExportObject: table's names failed"));
return Promise.reject(new Error("createExportObject: table's names failed"));
}

@@ -152,6 +38,10 @@ else {

default: {
reject(new Error('createExportObject: expMode ' + sqlObj.mode + ' not defined'));
errmsg =
'createExportObject: expMode ' + sqlObj.mode + ' not defined';
break;
}
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
if (tables.length > 0) {

@@ -164,11 +54,9 @@ retObj.database = sqlObj.database;

}
return Promise.resolve(retObj);
}
}
catch (err) {
reject(new Error('createExportObject: ' + err.message));
return Promise.reject(new Error('createExportObject: ' + err.message));
}
finally {
resolve(retObj);
}
}));
});
}

@@ -181,18 +69,14 @@ /**

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
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_%';";
let retQuery = [];
try {
retQuery = yield this._uSQLite.queryAll(mDb, sql, []);
}
catch (err) {
reject(new Error(`getTablesNames: ${err.message}`));
}
finally {
resolve(retQuery);
}
}));
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_%';";
let retQuery = [];
try {
retQuery = yield this._uSQLite.queryAll(mDb, sql, []);
return Promise.resolve(retQuery);
}
catch (err) {
return Promise.reject(new Error(`getTablesNames: ${err.message}`));
}
});

@@ -209,3 +93,3 @@ }

// get the last sync date
let stmt = `SELECT sync_date FROM sync_table;`;
const stmt = `SELECT sync_date FROM sync_table;`;
mDb.get(stmt, [], (err, row) => {

@@ -237,68 +121,69 @@ // process the row here

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let tables = [];
try {
// Loop through the tables
for (let i = 0; i < resTables.length; i++) {
let tableName;
let sqlStmt;
if (resTables[i].name) {
tableName = resTables[i].name;
}
else {
reject(new Error('GetTablesFull: no name'));
break;
}
if (resTables[i].sql) {
sqlStmt = resTables[i].sql;
}
else {
reject(new Error('GetTablesFull: no sql'));
break;
}
let table = {};
// create Table's Schema
const schema = yield this.getSchema(sqlStmt, tableName);
if (schema.length === 0) {
reject(new Error('GetTablesFull: no Schema returned'));
break;
}
// check schema validity
yield this._uJson.checkSchemaValidity(schema);
// create Table's indexes if any
const indexes = yield this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
// check indexes validity
yield this._uJson.checkIndexesValidity(indexes);
}
// create Table's Data
const query = `SELECT * FROM ${tableName};`;
const values = yield this.getValues(mDb, query, tableName);
table.name = tableName;
if (schema.length > 0) {
table.schema = schema;
}
else {
reject(new Error(`GetTablesFull: must contain schema`));
break;
}
if (indexes.length > 0) {
table.indexes = indexes;
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
reject(new Error(`GetTablesFull: table ${tableName} is not a jsonTable`));
}
tables.push(table);
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 = yield this.getSchema(sqlStmt, tableName);
if (schema.length === 0) {
errmsg = 'GetTablesFull: no Schema returned';
break;
}
// check schema validity
yield this._uJson.checkSchemaValidity(schema);
// create Table's indexes if any
const indexes = yield this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
// check indexes validity
yield this._uJson.checkIndexesValidity(indexes);
}
// create Table's Data
const query = `SELECT * FROM ${tableName};`;
const values = yield this.getValues(mDb, 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 (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesFull: table ${tableName} is not a jsonTable`;
break;
}
tables.push(table);
}
catch (err) {
reject(new Error(`GetTablesFull: ${err.message}`));
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
finally {
resolve(tables);
}
}));
return Promise.resolve(tables);
}
catch (err) {
return Promise.reject(new Error(`GetTablesFull: ${err.message}`));
}
});

@@ -314,50 +199,52 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let schema = [];
// take the substring between parenthesis
let openPar = sqlStmt.indexOf('(');
let closePar = sqlStmt.lastIndexOf(')');
let sstr = sqlStmt.substring(openPar + 1, closePar);
let isStrfTime = false;
if (sstr.includes('strftime'))
isStrfTime = true;
let sch = sstr.replace(/\n/g, '').split(',');
if (isStrfTime) {
let nSch = [];
for (let j = 0; j < sch.length; j++) {
if (sch[j].includes('strftime')) {
nSch.push(sch[j] + ',' + sch[j + 1]);
j++;
}
else {
nSch.push(sch[j]);
}
const schema = [];
// take the substring between parenthesis
const openPar = sqlStmt.indexOf('(');
const closePar = sqlStmt.lastIndexOf(')');
const sstr = sqlStmt.substring(openPar + 1, closePar);
let errmsg = '';
let isStrfTime = false;
if (sstr.includes('strftime'))
isStrfTime = true;
let sch = sstr.replace(/\n/g, '').split(',');
if (isStrfTime) {
const nSch = [];
for (let j = 0; j < sch.length; j++) {
if (sch[j].includes('strftime')) {
nSch.push(sch[j] + ',' + sch[j + 1]);
j++;
}
sch = [...nSch];
else {
nSch.push(sch[j]);
}
}
for (let j = 0; j < sch.length; j++) {
const rstr = sch[j].trim();
let idx = rstr.indexOf(' ');
//find the index of the first
let row = [rstr.slice(0, idx), rstr.slice(idx + 1)];
sch = [...nSch];
}
for (const rSch of sch) {
const rstr = rSch.trim();
const idx = rstr.indexOf(' ');
//find the index of the first
let row = [rstr.slice(0, idx), rstr.slice(idx + 1)];
if (row.length != 2) {
errmsg = `GetSchema: table ${tableName} row length != 2`;
break;
}
if (row[0].toUpperCase() != 'FOREIGN') {
schema.push({ column: row[0], value: row[1] });
}
else {
const oPar = rstr.indexOf('(');
const cPar = rstr.indexOf(')');
row = [rstr.slice(oPar + 1, cPar), rstr.slice(cPar + 2)];
if (row.length != 2) {
reject(new Error(`GetSchema: table ${tableName} row length != 2`));
errmsg = `GetSchema: table ${tableName} row length != 2`;
break;
}
if (row[0].toUpperCase() != 'FOREIGN') {
schema.push({ column: row[0], value: row[1] });
}
else {
const oPar = rstr.indexOf('(');
const cPar = rstr.indexOf(')');
row = [rstr.slice(oPar + 1, cPar), rstr.slice(cPar + 2)];
if (row.length != 2) {
reject(new Error(`GetSchema: table ${tableName} row length != 2`));
break;
}
schema.push({ foreignkey: row[0], value: row[1] });
}
schema.push({ foreignkey: row[0], value: row[1] });
}
resolve(schema);
}));
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(schema);
});

@@ -373,44 +260,44 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let indexes = [];
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 = yield this._uSQLite.queryAll(mDb, stmt, []);
if (retIndexes.length > 0) {
for (let j = 0; j < retIndexes.length; j++) {
const keys = Object.keys(retIndexes[j]);
if (keys.length === 3) {
if (retIndexes[j]['tbl_name'] === tableName) {
const sql = retIndexes[j]['sql'];
const mode = sql.includes('UNIQUE') ? 'UNIQUE' : '';
const oPar = sql.lastIndexOf('(');
const cPar = sql.lastIndexOf(')');
let index = {};
index.name = retIndexes[j]['name'];
index.value = sql.slice(oPar + 1, cPar);
if (mode.length > 0)
index.mode = mode;
indexes.push(index);
}
else {
reject(new Error(`GetIndexes: Table ${tableName} doesn't match`));
break;
}
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 = yield this._uSQLite.queryAll(mDb, 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 {
reject(new Error(`GetIndexes: Table ${tableName} creating indexes`));
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));
}
}
catch (err) {
reject(new Error(`GetIndexes: ${err.message}`));
}
finally {
resolve(indexes);
}
}));
return Promise.resolve(indexes);
}
catch (err) {
return Promise.reject(new Error(`GetIndexes: ${err.message}`));
}
});

@@ -426,36 +313,31 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let values = [];
try {
// get table column names and types
const tableNamesTypes = yield this._uJson.getTableColumnNamesTypes(mDb, tableName);
let rowNames = [];
if (Object.keys(tableNamesTypes).includes('names')) {
rowNames = tableNamesTypes.names;
}
else {
reject(new Error(`GetValues: Table ${tableName} no names`));
}
const retValues = yield this._uSQLite.queryAll(mDb, query, []);
for (let j = 0; j < retValues.length; j++) {
let row = [];
for (let k = 0; k < rowNames.length; k++) {
const nName = rowNames[k];
if (Object.keys(retValues[j]).includes(nName)) {
row.push(retValues[j][nName]);
}
else {
row.push('NULL');
}
const values = [];
try {
// get table column names and types
const tableNamesTypes = yield this._uJson.getTableColumnNamesTypes(mDb, 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 = yield this._uSQLite.queryAll(mDb, query, []);
for (const rValue of retValues) {
const row = [];
for (const rName of rowNames) {
if (Object.keys(rValue).includes(rName)) {
row.push(rValue[rName]);
}
values.push(row);
else {
row.push('NULL');
}
}
values.push(row);
}
catch (err) {
reject(new Error(`GetValues: ${err.message}`));
}
finally {
resolve(values);
}
}));
return Promise.resolve(values);
}
catch (err) {
return Promise.reject(new Error(`GetValues: ${err.message}`));
}
});

@@ -470,93 +352,94 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let tables = [];
let modTables = {};
let syncDate = 0;
let modTablesKeys = [];
try {
// Get the syncDate and the Modified Tables
const partialModeData = yield this.getPartialModeData(mDb, resTables);
if (Object.keys(partialModeData).includes('syncDate')) {
syncDate = partialModeData.syncDate;
const tables = [];
let modTables = {};
let syncDate = 0;
let modTablesKeys = [];
let errmsg = '';
try {
// Get the syncDate and the Modified Tables
const partialModeData = yield this.getPartialModeData(mDb, 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;
}
if (Object.keys(partialModeData).includes('modTables')) {
modTables = partialModeData.modTables;
modTablesKeys = Object.keys(modTables);
else {
errmsg = 'GetTablesFull: no name';
break;
}
// Loop trough tables
for (let i = 0; i < resTables.length; i++) {
let tableName = '';
let sqlStmt = '';
if (resTables[i].name) {
tableName = resTables[i].name;
}
else {
reject(new Error('GetTablesFull: no name'));
break;
}
if (resTables[i].sql) {
sqlStmt = resTables[i].sql;
}
else {
reject(new Error('GetTablesFull: no sql'));
break;
}
if (modTablesKeys.length == 0 ||
modTablesKeys.indexOf(tableName) === -1 ||
modTables[tableName] == 'No') {
continue;
}
let table = {};
let schema = [];
let indexes = [];
table.name = resTables[i];
if (modTables[table.name] === 'Create') {
// create Table's Schema
schema = yield this.getSchema(sqlStmt, tableName);
if (schema.length > 0) {
// check schema validity
yield this._uJson.checkSchemaValidity(schema);
}
// create Table's indexes if any
indexes = yield this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
// check indexes validity
yield this._uJson.checkIndexesValidity(indexes);
}
}
// 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 = yield this.getValues(mDb, query, tableName);
// check the table object validity
table.name = tableName;
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 = [];
table.name = rTable;
if (modTables[table.name] === 'Create') {
// create Table's Schema
schema = yield this.getSchema(sqlStmt, tableName);
if (schema.length > 0) {
table.schema = schema;
// check schema validity
yield this._uJson.checkSchemaValidity(schema);
}
// create Table's indexes if any
indexes = yield this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
table.indexes = indexes;
// check indexes validity
yield this._uJson.checkIndexesValidity(indexes);
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
reject(new Error(`GetTablesPartial: table ${tableName} is not a jsonTable`));
}
tables.push(table);
}
// 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 = yield this.getValues(mDb, 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 (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesPartial: table ${tableName} is not a jsonTable`;
break;
}
tables.push(table);
}
catch (err) {
reject(new Error(`GetTablesPartial: ${err.message}`));
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
finally {
resolve(tables);
}
}));
return Promise.resolve(tables);
}
catch (err) {
return Promise.reject(new Error(`GetTablesPartial: ${err.message}`));
}
});

@@ -571,26 +454,22 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let retData = {};
try {
// get the synchronization date
const syncDate = yield this.getSyncDate(mDb);
if (syncDate <= 0) {
reject(new Error(`GetPartialModeData: no syncDate`));
}
// get the tables which have been updated
// since last synchronization
const modTables = yield this.getTablesModified(mDb, resTables, syncDate);
if (modTables.length <= 0) {
reject(new Error(`GetPartialModeData: no modTables`));
}
retData.syncDate = syncDate;
retData.modTables = modTables;
const retData = {};
try {
// get the synchronization date
const syncDate = yield this.getSyncDate(mDb);
if (syncDate <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no syncDate`));
}
catch (err) {
reject(new Error(`GetPartialModeData: ${err.message}`));
// get the tables which have been updated
// since last synchronization
const modTables = yield this.getTablesModified(mDb, resTables, syncDate);
if (modTables.length <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no modTables`));
}
finally {
resolve(retData);
}
}));
retData.syncDate = syncDate;
retData.modTables = modTables;
return Promise.resolve(retData);
}
catch (err) {
return Promise.reject(new Error(`GetPartialModeData: ${err.message}`));
}
});

@@ -600,42 +479,44 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
try {
let retModified = {};
for (let i = 0; i < tables.length; i++) {
let mode;
// get total count of the table
let stmt = 'SELECT count(*) AS tcount ';
stmt += `FROM ${tables[i].name};`;
let retQuery = yield this._uSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) {
reject(new Error('GetTableModified: total ' + 'count not returned'));
}
const totalCount = retQuery[0]['tcount'];
// get total count of modified since last sync
stmt = 'SELECT count(*) AS mcount FROM ';
stmt += `${tables[i].name} WHERE last_modified > `;
stmt += `${syncDate};`;
retQuery = yield this._uSQLite.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 = tables[i].name;
retModified[key] = mode;
if (i === tables.length - 1)
resolve(retModified);
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 = yield this._uSQLite.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 = yield this._uSQLite.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;
}
catch (err) {
reject(new Error(`GetTableModified: ${err.message}`));
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
}));
return Promise.resolve(retModified);
}
catch (err) {
return Promise.reject(new Error(`GetTableModified: ${err.message}`));
}
});

@@ -642,0 +523,0 @@ }

2

electron/dist/esm/electron/src/electron-utils/ImportExportJson/importFromJson.d.ts

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

import { JsonSQLite } from '../../definitions';
import type { JsonSQLite } from '../../definitions';
export declare class ImportFromJson {

@@ -3,0 +3,0 @@ private _uJson;

33

electron/dist/esm/electron/src/electron-utils/ImportExportJson/importFromJson.js
import { __awaiter } from "tslib";
import { UtilsDrop } from '../utilsDrop';
import { UtilsSQLite } from '../utilsSQLite';
import { UtilsJson } from './utilsJson';
import { UtilsSQLite } from '../utilsSQLite';
import { UtilsDrop } from '../utilsDrop';
export class ImportFromJson {

@@ -17,3 +17,3 @@ constructor() {

createDatabaseSchema(mDB, jsonData) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let changes = -1;

@@ -32,11 +32,11 @@ const version = jsonData.version;

changes = yield this._uJson.createSchema(mDB, jsonData);
resolve(changes);
return Promise.resolve(changes);
}
catch (err) {
reject(new Error('CreateDatabaseSchema: ' + `${err.message}`));
return Promise.reject(new Error('CreateDatabaseSchema: ' + `${err.message}`));
}
}));
});
}
createTablesData(mDB, jsonData) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let changes = 0;

@@ -53,10 +53,9 @@ let isValue = false;

catch (err) {
reject(new Error(`createTablesData: ${err.message}`));
return Promise.reject(new Error(`createTablesData: ${err.message}`));
}
for (let i = 0; i < jsonData.tables.length; i++) {
if (jsonData.tables[i].values != null &&
jsonData.tables[i].values.length >= 1) {
for (const jTable of jsonData.tables) {
if (jTable.values != null && jTable.values.length >= 1) {
// Create the table's data
try {
lastId = yield this._uJson.createDataTable(mDB, jsonData.tables[i], jsonData.mode);
lastId = yield this._uJson.createDataTable(mDB, jTable, jsonData.mode);
if (lastId < 0)

@@ -77,6 +76,6 @@ break;

changes = (yield this._uSQLite.dbChanges(mDB)) - initChanges;
resolve(changes);
return Promise.resolve(changes);
}
catch (err) {
reject(new Error('createTablesData: ' + `${err.message}`));
return Promise.reject(new Error('createTablesData: ' + `${err.message}`));
}

@@ -87,11 +86,11 @@ }

yield this._uSQLite.rollbackTransaction(mDB, true);
reject(new Error(`createTablesData: ${msg}`));
return Promise.reject(new Error(`createTablesData: ${msg}`));
}
catch (err) {
reject(new Error('createTablesData: ' + `${err.message}: ${msg}`));
return Promise.reject(new Error('createTablesData: ' + `${err.message}: ${msg}`));
}
}
}));
});
}
}
//# sourceMappingURL=importFromJson.js.map

2

electron/dist/esm/electron/src/electron-utils/ImportExportJson/utilsJson.d.ts

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

import { JsonColumn, JsonIndex } from '../../definitions';
import type { JsonColumn, JsonIndex } from '../../definitions';
export declare class UtilsJson {

@@ -3,0 +3,0 @@ private _uSQLite;

390

electron/dist/esm/electron/src/electron-utils/ImportExportJson/utilsJson.js

@@ -45,45 +45,43 @@ import { __awaiter } from "tslib";

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
// create the database schema
let changes = 0;
// create the database schema
let changes = 0;
try {
// start a transaction
yield this._uSQLite.beginTransaction(mDB, true);
}
catch (err) {
return Promise.reject(new Error(`CreateDatabaseSchema: ${err.message}`));
}
const stmts = yield this.createSchemaStatement(jsonData);
if (stmts.length > 0) {
const schemaStmt = stmts.join('\n');
try {
// start a transaction
yield this._uSQLite.beginTransaction(mDB, true);
}
catch (err) {
reject(new Error(`CreateDatabaseSchema: ${err.message}`));
}
const stmts = yield this.createSchemaStatement(jsonData);
if (stmts.length > 0) {
const schemaStmt = stmts.join('\n');
try {
changes = yield this._uSQLite.execute(mDB, schemaStmt);
if (changes < 0) {
try {
yield this._uSQLite.rollbackTransaction(mDB, true);
}
catch (err) {
reject(new Error('CreateSchema: changes < 0 ' + `${err.message}`));
}
}
}
catch (err) {
const msg = err.message;
changes = yield this._uSQLite.execute(mDB, schemaStmt);
if (changes < 0) {
try {
yield this._uSQLite.rollbackTransaction(mDB, true);
reject(new Error(`CreateSchema: ${msg}`));
}
catch (err) {
reject(new Error('CreateSchema: changes < 0 ' + `${err.message}: ${msg}`));
return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}`));
}
}
}
try {
yield this._uSQLite.commitTransaction(mDB, true);
resolve(changes);
}
catch (err) {
reject(new Error('CreateSchema: commit ' + `${err.message}`));
const msg = err.message;
try {
yield this._uSQLite.rollbackTransaction(mDB, true);
return Promise.reject(new Error(`CreateSchema: ${msg}`));
}
catch (err) {
return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}: ${msg}`));
}
}
}));
}
try {
yield this._uSQLite.commitTransaction(mDB, true);
return Promise.resolve(changes);
}
catch (err) {
return Promise.reject(new Error('CreateSchema: commit ' + `${err.message}`));
}
});

@@ -97,25 +95,24 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise(resolve => {
let statements = [];
// Prepare the statement to execute
for (let i = 0; i < jsonData.tables.length; i++) {
if (jsonData.tables[i].schema != null &&
jsonData.tables[i].schema.length >= 1) {
const statements = [];
// 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 ' + `${jsonData.tables[i].name} (`);
for (let j = 0; j < jsonData.tables[i].schema.length; j++) {
if (j === jsonData.tables[i].schema.length - 1) {
if (jsonData.tables[i].schema[j].column) {
statements.push(`${jsonData.tables[i].schema[j].column} ${jsonData.tables[i].schema[j].value}`);
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.column) {
statements.push(`${jTable.schema.column} ${jTable.schema[j].value}`);
}
else if (jsonData.tables[i].schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jsonData.tables[i].schema[j].foreignkey}) ${jsonData.tables[i].schema[j].value}`);
else if (jTable.schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value}`);
}
}
else {
if (jsonData.tables[i].schema[j].column) {
statements.push(`${jsonData.tables[i].schema[j].column} ${jsonData.tables[i].schema[j].value},`);
if (jTable.schema[j].column) {
statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value},`);
}
else if (jsonData.tables[i].schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jsonData.tables[i].schema[j].foreignkey}) ${jsonData.tables[i].schema[j].value},`);
else if (jTable.schema[j].foreignkey) {
statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value},`);
}

@@ -127,8 +124,8 @@ }

let trig = 'CREATE TRIGGER IF NOT EXISTS ';
trig += `${jsonData.tables[i].name}`;
trig += `${jTable.name}`;
trig += `_trigger_last_modified `;
trig += `AFTER UPDATE ON ${jsonData.tables[i].name} `;
trig += `AFTER UPDATE ON ${jTable.name} `;
trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
trig += 'OLD.last_modified BEGIN UPDATE ';
trig += `${jsonData.tables[i].name} `;
trig += `${jTable.name} `;
trig += `SET last_modified = `;

@@ -138,9 +135,7 @@ trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";

}
if (jsonData.tables[i].indexes != null &&
jsonData.tables[i].indexes.length >= 1) {
for (let j = 0; j < jsonData.tables[i].indexes.length; j++) {
const index = jsonData.tables[i].indexes[j];
const tableName = jsonData.tables[i].name;
let stmt = `CREATE ${Object.keys(index).includes('mode') ? index.mode + ' ' : ''}INDEX `;
stmt += `${index.name} ON ${tableName} (${index.value});`;
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 `;
stmt += `${jIndex.name} ON ${tableName} (${jIndex.value});`;
statements.push(stmt);

@@ -150,4 +145,7 @@ }

}
resolve(statements);
});
return Promise.resolve(statements);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -163,61 +161,59 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let lastId = -1;
try {
// Check if the table exists
const tableExists = yield this.isTableExists(mDB, true, table.name);
if (!tableExists) {
reject(new Error('CreateDataTable: Table ' + `${table.name} does not exist`));
let lastId = -1;
try {
// Check if the table exists
const tableExists = yield this.isTableExists(mDB, true, table.name);
if (!tableExists) {
return Promise.reject(new Error('CreateDataTable: Table ' + `${table.name} does not exist`));
}
// Get the column names and types
const tableNamesTypes = yield this.getTableColumnNamesTypes(mDB, table.name);
const tableColumnTypes = tableNamesTypes.types;
const tableColumnNames = tableNamesTypes.names;
if (tableColumnTypes.length === 0) {
return Promise.reject(new Error('CreateDataTable: Table ' + `${table.name} info does not exist`));
}
// Loop on Table Values
for (let j = 0; j < table.values.length; j++) {
// Check the row number of columns
if (table.values[j].length != tableColumnTypes.length) {
return Promise.reject(new Error(`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct length`));
}
// Get the column names and types
const tableNamesTypes = yield this.getTableColumnNamesTypes(mDB, table.name);
const tableColumnTypes = tableNamesTypes.types;
const tableColumnNames = tableNamesTypes.names;
if (tableColumnTypes.length === 0) {
reject(new Error('CreateDataTable: Table ' + `${table.name} info does not exist`));
// Check the column's type before proceeding
const isColumnTypes = yield this.checkColumnTypes(tableColumnTypes, table.values[j]);
if (!isColumnTypes) {
return Promise.reject(new Error(`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct types`));
}
// Loop on Table Values
for (let j = 0; j < table.values.length; j++) {
// Check the row number of columns
if (table.values[j].length != tableColumnTypes.length) {
reject(new Error(`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct length`));
const retisIdExists = yield this.isIdExists(mDB, table.name, tableColumnNames[0], table.values[j][0]);
let stmt;
if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
// Insert
const nameString = tableColumnNames.join();
const questionMarkString = yield this.createQuestionMarkString(tableColumnNames.length);
stmt = `INSERT INTO ${table.name} (${nameString}) VALUES (`;
stmt += `${questionMarkString});`;
}
else {
// Update
const setString = yield this.setNameForUpdate(tableColumnNames);
if (setString.length === 0) {
return Promise.reject(new Error(`CreateDataTable: Table ${table.name} ` +
`values row ${j} not set to String`));
}
// Check the column's type before proceeding
const isColumnTypes = yield this.checkColumnTypes(tableColumnTypes, table.values[j]);
if (!isColumnTypes) {
reject(new Error(`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct types`));
}
const retisIdExists = yield this.isIdExists(mDB, table.name, tableColumnNames[0], table.values[j][0]);
let stmt;
if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
// Insert
const nameString = tableColumnNames.join();
const questionMarkString = yield this.createQuestionMarkString(tableColumnNames.length);
stmt = `INSERT INTO ${table.name} (${nameString}) VALUES (`;
stmt += `${questionMarkString});`;
}
else {
// Update
const setString = yield this.setNameForUpdate(tableColumnNames);
if (setString.length === 0) {
reject(new Error(`CreateDataTable: Table ${table.name} ` +
`values row ${j} not set to String`));
}
stmt =
`UPDATE ${table.name} SET ${setString} WHERE ` +
`${tableColumnNames[0]} = ${table.values[j][0]};`;
}
lastId = yield this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
if (lastId < 0) {
reject(new Error('CreateDataTable: lastId < 0'));
}
stmt =
`UPDATE ${table.name} SET ${setString} WHERE ` +
`${tableColumnNames[0]} = ${table.values[j][0]};`;
}
resolve(lastId);
lastId = yield this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
if (lastId < 0) {
return Promise.reject(new Error('CreateDataTable: lastId < 0'));
}
}
catch (err) {
reject(new Error(`CreateDataTable: ${err.message}`));
}
}));
return Promise.resolve(lastId);
}
catch (err) {
return Promise.reject(new Error(`CreateDataTable: ${err.message}`));
}
});

@@ -231,6 +227,6 @@ }

getTableColumnNamesTypes(mDB, tableName) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let resQuery = [];
let retNames = [];
let retTypes = [];
const retNames = [];
const retTypes = [];
const query = `PRAGMA table_info('${tableName}');`;

@@ -240,13 +236,13 @@ try {

if (resQuery.length > 0) {
for (let i = 0; i < resQuery.length; i++) {
retNames.push(resQuery[i].name);
retTypes.push(resQuery[i].type);
for (const query of resQuery) {
retNames.push(query.name);
retTypes.push(query.type);
}
}
resolve({ names: retNames, types: retTypes });
return Promise.resolve({ names: retNames, types: retTypes });
}
catch (err) {
reject(new Error('GetTableColumnNamesTypes: ' + `${err.message}`));
return Promise.reject(new Error('GetTableColumnNamesTypes: ' + `${err.message}`));
}
}));
});
}

@@ -259,4 +255,4 @@ /**

checkColumnTypes(tableTypes, rowValues) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let isType = true;
return __awaiter(this, void 0, void 0, function* () {
const isType = true;
for (let i = 0; i < rowValues.length; i++) {

@@ -268,8 +264,8 @@ if (rowValues[i].toString().toUpperCase() != 'NULL') {

catch (err) {
reject(new Error('checkColumnTypes: Type not found'));
return Promise.reject(new Error('checkColumnTypes: Type not found'));
}
}
}
resolve(isType);
}));
return Promise.resolve(isType);
});
}

@@ -282,3 +278,3 @@ /**

isType(type, value) {
return new Promise((resolve, reject) => {
return __awaiter(this, void 0, void 0, function* () {
let ret = false;

@@ -296,6 +292,6 @@ if (type === 'NULL' && typeof value === 'object')

if (ret) {
resolve();
return Promise.resolve();
}
else {
reject(new Error('IsType: not a SQL Type'));
return Promise.reject(new Error('IsType: not a SQL Type'));
}

@@ -312,3 +308,3 @@ });

isIdExists(db, dbName, firstColumnName, key) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let ret = false;

@@ -318,11 +314,11 @@ const query = `SELECT ${firstColumnName} FROM ` +

try {
const resQuery = yield this._uSQLite.queryAll(db, query, []);
if (resQuery.length === 1)
ret = true;
return Promise.resolve(ret);
}
catch (err) {
reject(new Error(`IsIdExists: ${err.message}`));
return Promise.reject(new Error(`IsIdExists: ${err.message}`));
}
const resQuery = yield this._uSQLite.queryAll(db, query, []);
if (resQuery.length === 1)
ret = true;
resolve(ret);
}));
});
}

@@ -335,3 +331,3 @@ /**

return new Promise((resolve, reject) => {
var retString = '';
let retString = '';
for (let i = 0; i < length; i++) {

@@ -354,13 +350,13 @@ retString += '?,';

setNameForUpdate(names) {
return new Promise((resolve, reject) => {
var retString = '';
for (let i = 0; i < names.length; i++) {
retString += `${names[i]} = ? ,`;
return __awaiter(this, void 0, void 0, function* () {
let retString = '';
for (const name of names) {
retString += `${name} = ? ,`;
}
if (retString.length > 1) {
retString = retString.slice(0, -1);
resolve(retString);
return Promise.resolve(retString);
}
else {
reject(new Error('SetNameForUpdate: length = 0'));
return Promise.reject(new Error('SetNameForUpdate: length = 0'));
}

@@ -384,3 +380,3 @@ });

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keyFirstLevel.indexOf(key) === -1)

@@ -399,4 +395,4 @@ return false;

if (key === 'tables') {
for (let i = 0; i < obj[key].length; i++) {
const retTable = this.isTable(obj[key][i]);
for (const oKey of obj[key]) {
const retTable = this.isTable(oKey);
if (!retTable)

@@ -414,8 +410,3 @@ return false;

isTable(obj) {
const keyTableLevel = [
'name',
'schema',
'indexes',
'values',
];
const keyTableLevel = ['name', 'schema', 'indexes', 'values'];
let nbColumn = 0;

@@ -425,3 +416,3 @@ if (obj == null ||

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keyTableLevel.indexOf(key) === -1)

@@ -450,4 +441,4 @@ return false;

if (key === 'indexes') {
for (let i = 0; i < obj[key].length; i++) {
const retIndexes = this.isIndexes(obj[key][i]);
for (const oKey of obj[key]) {
const retIndexes = this.isIndexes(oKey);
if (!retIndexes)

@@ -459,5 +450,4 @@ return false;

if (nbColumn > 0) {
for (let i = 0; i < obj[key].length; i++) {
if (typeof obj[key][i] != 'object' ||
obj[key][i].length != nbColumn)
for (const oKey of obj[key]) {
if (typeof oKey != 'object' || oKey.length != nbColumn)
return false;

@@ -479,3 +469,3 @@ }

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keySchemaLevel.indexOf(key) === -1)

@@ -501,3 +491,3 @@ return false;

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keyIndexesLevel.indexOf(key) === -1)

@@ -521,22 +511,20 @@ return false;

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
for (let i = 0; i < schema.length; i++) {
let sch = {};
let 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;
}
let isValid = this.isSchema(sch);
if (!isValid) {
reject(new Error(`CheckSchemaValidity: schema[${i}] not valid`));
}
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;
}
resolve();
}));
if (keys.includes('value')) {
sch.value = schema[i].value;
}
if (keys.includes('foreignkey')) {
sch.foreignkey = schema[i].foreignkey;
}
const isValid = this.isSchema(sch);
if (!isValid) {
return Promise.reject(new Error(`CheckSchemaValidity: schema[${i}] not valid`));
}
}
return Promise.resolve();
});

@@ -550,22 +538,20 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
for (let i = 0; i < indexes.length; i++) {
let index = {};
let 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;
}
let isValid = this.isIndexes(index);
if (!isValid) {
reject(new Error(`CheckIndexesValidity: indexes[${i}] not valid`));
}
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;
}
resolve();
}));
if (keys.includes('name')) {
index.name = indexes[i].name;
}
if (keys.includes('mode')) {
index.mode = indexes[i].mode;
}
const isValid = this.isIndexes(index);
if (!isValid) {
return Promise.reject(new Error(`CheckIndexesValidity: indexes[${i}] not valid`));
}
}
return Promise.resolve();
});

@@ -572,0 +558,0 @@ }

169

electron/dist/esm/electron/src/electron-utils/utilsDrop.js

@@ -13,19 +13,17 @@ import { __awaiter } from "tslib";

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
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_%';";
let retArr = [];
try {
const retQuery = yield this._uSQLite.queryAll(mDb, sql, []);
for (let i = 0; i < retQuery.length; i++) {
retArr.push(retQuery[i].name);
}
resolve(retArr);
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_%';";
const retArr = [];
try {
const retQuery = yield this._uSQLite.queryAll(mDb, sql, []);
for (const query of retQuery) {
retArr.push(query.name);
}
catch (err) {
reject(new Error(`getTablesNames: ${err.message}`));
}
}));
return Promise.resolve(retArr);
}
catch (err) {
return Promise.reject(new Error(`getTablesNames: ${err.message}`));
}
});

@@ -40,44 +38,41 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let msg = '';
switch (type) {
case 'index':
msg = 'DropIndexes';
break;
case 'trigger':
msg = 'DropTriggers';
break;
case 'table':
msg = 'DropTables';
break;
default:
reject(new Error(`DropElements: ${type} ` + 'not found'));
break;
}
// get the element's names
let stmt = 'SELECT name FROM sqlite_master WHERE ';
stmt += `type = '${type}' AND name NOT LIKE 'sqlite_%';`;
try {
let elements = yield this._uSQLite.queryAll(db, stmt, []);
if (elements.length > 0) {
let upType = type.toUpperCase();
let statements = [];
for (let i = 0; i < elements.length; i++) {
let stmt = `DROP ${upType} IF EXISTS `;
stmt += `${elements[i].name};`;
statements.push(stmt);
let msg = '';
switch (type) {
case 'index':
msg = 'DropIndexes';
break;
case 'trigger':
msg = 'DropTriggers';
break;
case 'table':
msg = 'DropTables';
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}' AND name NOT LIKE 'sqlite_%';`;
try {
const elements = yield this._uSQLite.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 = yield this._uSQLite.prepareRun(db, stmt, []);
if (lastId < 0) {
return Promise.reject(new Error(`${msg}: lastId < 0`));
}
for (let i = 0; i < statements.length; i++) {
const lastId = yield this._uSQLite.prepareRun(db, statements[i], []);
if (lastId < 0) {
reject(new Error(`${msg}: lastId < 0`));
}
}
}
resolve();
}
catch (err) {
reject(new Error(`${msg}: ${err.message}`));
}
}));
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`${msg}: ${err.message}`));
}
});

@@ -92,18 +87,16 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
try {
// drop tables
yield this.dropElements(db, 'table');
// drop indexes
yield this.dropElements(db, 'index');
// drop triggers
yield this.dropElements(db, 'trigger');
// vacuum the database
yield this._uSQLite.prepareRun(db, 'VACUUM;', []);
resolve();
}
catch (err) {
reject(new Error(`DropAll: ${err.message}`));
}
}));
try {
// drop tables
yield this.dropElements(db, 'table');
// drop indexes
yield this.dropElements(db, 'index');
// drop triggers
yield this.dropElements(db, 'trigger');
// vacuum the database
yield this._uSQLite.prepareRun(db, 'VACUUM;', []);
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DropAll: ${err.message}`));
}
});

@@ -118,21 +111,19 @@ }

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
const tempTables = Object.keys(alterTables);
const statements = [];
for (let i = 0; i < tempTables.length; i++) {
let stmt = 'DROP TABLE IF EXISTS ';
stmt += `_temp_${tempTables[i]};`;
statements.push(stmt);
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 = yield this._uSQLite.execute(db, statements.join('\n'));
if (changes < 0) {
return Promise.reject(new Error('DropTempTables: changes < 0'));
}
try {
const changes = yield this._uSQLite.execute(db, statements.join('\n'));
if (changes < 0) {
reject(new Error('DropTempTables: changes < 0'));
}
resolve();
}
catch (err) {
reject(new Error(`DropTempTables: ${err.message}`));
}
}));
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`DropTempTables: ${err.message}`));
}
});

@@ -139,0 +130,0 @@ }

40

electron/dist/esm/electron/src/electron-utils/utilsEncryption.js
import { __awaiter } from "tslib";
import { UtilsFile } from './utilsFile';
import { UtilsSQLite } from './utilsSQLite';
//1234567890123456789012345678901234567890123456789012345678901234567890
export class UtilsEncryption {

@@ -16,7 +15,7 @@ constructor() {

encryptDatabase(pathDB, password) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const msg = 'EncryptDatabase: ';
let retB = this._uFile.isPathExists(pathDB);
const retB = this._uFile.isPathExists(pathDB);
if (retB) {
let tempPath = this._uFile.getFilePath('temp.db');
const tempPath = this._uFile.getFilePath('temp.db');
try {

@@ -30,12 +29,12 @@ yield this._uFile.renameFilePath(pathDB, tempPath);

mDB.close();
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`${msg} ${err.message} `));
return Promise.reject(new Error(`${msg} ${err.message} `));
}
}
else {
reject(new Error(`${msg}file path ${pathDB} ` + 'does not exist'));
return Promise.reject(new Error(`${msg}file path ${pathDB} ` + 'does not exist'));
}
}));
});
}

@@ -49,14 +48,19 @@ /**

sqlcipherEncrypt(oDB, pathDB, password) {
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
oDB.serialize(() => {
let stmt = `ATTACH DATABASE '${pathDB}' `;
stmt += `AS encrypted KEY '${password}';`;
oDB.run(stmt);
oDB.run("SELECT sqlcipher_export('encrypted');");
oDB.run('DETACH DATABASE encrypted;');
});
resolve();
}));
return __awaiter(this, void 0, void 0, function* () {
try {
oDB.serialize(() => {
let stmt = `ATTACH DATABASE '${pathDB}' `;
stmt += `AS encrypted KEY '${password}';`;
oDB.run(stmt);
oDB.run("SELECT sqlcipher_export('encrypted');");
oDB.run('DETACH DATABASE encrypted;');
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});
}
}
//# sourceMappingURL=utilsEncryption.js.map

100

electron/dist/esm/electron/src/electron-utils/utilsFile.js
import { __awaiter } from "tslib";
// eslint-disable-next-line @typescript-eslint/no-var-requires
const app = require('electron').remote.app;
export class UtilsFile {

@@ -10,3 +12,2 @@ constructor() {

this.HomeDir = '';
this.appPath = null;
this.Path = require('path');

@@ -16,3 +17,2 @@ this.NodeFs = require('fs');

this.HomeDir = this.Os.homedir();
const app = require('electron').remote.app;
this.appPath = app.getAppPath();

@@ -134,5 +134,5 @@ let sep = '/';

getFileList(path) {
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const filenames = this.NodeFs.readdirSync(path);
let dbs = [];
const dbs = [];
filenames.forEach((file) => {

@@ -142,4 +142,4 @@ if (this.Path.extname(file) == '.db')

});
resolve(dbs);
}));
return Promise.resolve(dbs);
});
}

@@ -152,8 +152,8 @@ /**

copyFromAssetToDatabase(db, toDb) {
return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const pAsset = this.Path.join(this.getAssetsDatabasesPath(), db);
const pDb = this.Path.join(this.getDatabasesPath(), toDb);
yield this.copyFilePath(pAsset, pDb);
resolve();
}));
return Promise.resolve();
});
}

@@ -167,3 +167,3 @@ /**

copyFileName(fileName, toFileName) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
// get File Paths

@@ -175,12 +175,12 @@ const filePath = this.getFilePath(fileName);

yield this.copyFilePath(filePath, toFilePath);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`CopyFileName: ${err.message}`));
return Promise.reject(new Error(`CopyFileName: ${err.message}`));
}
}
else {
reject(new Error('CopyFileName: cannot get the ' + 'filePath'));
return Promise.reject(new Error('CopyFileName: cannot get the ' + 'filePath'));
}
}));
});
}

@@ -194,3 +194,3 @@ /**

copyFilePath(filePath, toFilePath) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
if (filePath.length !== 0 && toFilePath.length !== 0) {

@@ -203,16 +203,16 @@ // check filePath exists

this.NodeFs.copyFileSync(filePath, toFilePath);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`CopyFilePath: ${err.message}`));
return Promise.reject(new Error(`CopyFilePath: ${err.message}`));
}
}
else {
reject(new Error('CopyFilePath: filePath does not ' + 'exist'));
return Promise.reject(new Error('CopyFilePath: filePath does not ' + 'exist'));
}
}
else {
reject(new Error('CopyFilePath: cannot get the ' + 'filePath'));
return Promise.reject(new Error('CopyFilePath: cannot get the ' + 'filePath'));
}
}));
});
}

@@ -225,3 +225,3 @@ /**

deleteFileName(fileName) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
// get file path

@@ -232,12 +232,12 @@ const filePath = this.getFilePath(fileName);

yield this.deleteFilePath(filePath);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error('DeleteFileName: delete filePath ' + `failed ${err.message}`));
return Promise.reject(new Error('DeleteFileName: delete filePath ' + `failed ${err.message}`));
}
}
else {
reject(new Error('DeleteFileName: get filePath ' + 'failed'));
return Promise.reject(new Error('DeleteFileName: get filePath ' + 'failed'));
}
}));
});
}

@@ -250,3 +250,3 @@ /**

deleteFilePath(filePath) {
return new Promise((resolve, reject) => {
return __awaiter(this, void 0, void 0, function* () {
if (filePath.length !== 0) {

@@ -258,14 +258,14 @@ // check if path exists

this.NodeFs.unlinkSync(filePath);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error('DeleteFilePath: ' + `${err.message}`));
return Promise.reject(new Error('DeleteFilePath: ' + `${err.message}`));
}
}
else {
resolve();
return Promise.resolve();
}
}
else {
reject(new Error('DeleteFilePath: delete filePath' + 'failed'));
return Promise.reject(new Error('DeleteFilePath: delete filePath' + 'failed'));
}

@@ -280,3 +280,3 @@ });

renameFileName(fileName, toFileName) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
// get File Paths

@@ -288,12 +288,12 @@ const filePath = this.getFilePath(fileName);

yield this.renameFilePath(filePath, toFilePath);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`RenameFileName: ${err.message}`));
return Promise.reject(new Error(`RenameFileName: ${err.message}`));
}
}
else {
reject(new Error('RenameFileName: filePaths do not ' + 'exist'));
return Promise.reject(new Error('RenameFileName: filePaths do not ' + 'exist'));
}
}));
});
}

@@ -306,3 +306,3 @@ /**

renameFilePath(filePath, toFilePath) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
if (filePath.length !== 0 && toFilePath.length !== 0) {

@@ -316,16 +316,16 @@ // check filePath exists

this.NodeFs.renameSync(filePath, toFilePath);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error('RenameFilePath: ' + `${err.message}`));
return Promise.reject(new Error('RenameFilePath: ' + `${err.message}`));
}
}
else {
reject(new Error('RenameFilePath: filePath ' + 'does not exist'));
return Promise.reject(new Error('RenameFilePath: filePath ' + 'does not exist'));
}
}
else {
reject(new Error('RenameFilePath: filePath not found'));
return Promise.reject(new Error('RenameFilePath: filePath not found'));
}
}));
});
}

@@ -338,3 +338,3 @@ /**

restoreFileName(fileName, prefix) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const mFileName = `${prefix}-${fileName}`;

@@ -349,16 +349,16 @@ // check if file exists

yield this.renameFileName(mFileName, fileName);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error('RestoreFileName: ' + `${err.message}`));
return Promise.reject(new Error('RestoreFileName: ' + `${err.message}`));
}
}
else {
reject(new Error(`RestoreFileName: ${fileName} ` + 'does not exist'));
return Promise.reject(new Error(`RestoreFileName: ${fileName} ` + 'does not exist'));
}
}
else {
reject(new Error(`RestoreFileName: ${mFileName} ` + 'does not exist'));
return Promise.reject(new Error(`RestoreFileName: ${mFileName} ` + 'does not exist'));
}
}));
});
}

@@ -390,5 +390,5 @@ /**

_mkdirSyncRecursive(directory) {
var path = directory.replace(/\/$/, '').split('/');
for (var i = 1; i <= path.length; i++) {
var segment = path.slice(0, i).join('/');
const path = directory.replace(/\/$/, '').split('/');
for (let i = 1; i <= path.length; i++) {
const segment = path.slice(0, i).join('/');
segment.length > 0 && !this.NodeFs.existsSync(segment)

@@ -395,0 +395,0 @@ ? this.NodeFs.mkdirSync(segment)

13

electron/dist/esm/electron/src/electron-utils/utilsSQLite.d.ts

@@ -41,2 +41,9 @@ export declare class UtilsSQLite {

/**
* PragmaReKey
* @param mDB
* @param password
* @param newpassword
*/
private pragmaReKey;
/**
* BeginTransaction

@@ -77,2 +84,8 @@ * @param db

/**
* ExecDB
* @param mDB
* @param sql
*/
private execDB;
/**
* ExecuteSet

@@ -79,0 +92,0 @@ * @param db

296

electron/dist/esm/electron/src/electron-utils/utilsSQLite.js
import { __awaiter } from "tslib";
export class UtilsSQLite {
constructor() {
// eslint-disable-next-line @typescript-eslint/no-var-requires
this.JSQlite = require('@journeyapps/sqlcipher').verbose();

@@ -12,4 +13,4 @@ }

openOrCreateDatabase(pathDB, password) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let msg = 'OpenOrCreateDatabase: ';
return __awaiter(this, void 0, void 0, function* () {
const msg = 'OpenOrCreateDatabase: ';
// open sqlite3 database

@@ -24,3 +25,3 @@ const mDB = new this.JSQlite.Database(pathDB, {

catch (err) {
reject(new Error(msg + `dbChanges ${err.message}`));
return Promise.reject(new Error(msg + `dbChanges ${err.message}`));
}

@@ -35,3 +36,3 @@ try {

// Check Version
let curVersion = yield this.getVersion(mDB);
const curVersion = yield this.getVersion(mDB);
if (curVersion === 0) {

@@ -42,10 +43,10 @@ yield this.setVersion(mDB, 1);

catch (err) {
reject(new Error(msg + `${err.message}`));
return Promise.reject(new Error(msg + `${err.message}`));
}
resolve(mDB);
return Promise.resolve(mDB);
}
else {
reject(new Error(msg + 'open database failed'));
return Promise.reject(new Error(msg + 'open database failed'));
}
}));
});
}

@@ -58,13 +59,15 @@ /**

setCipherPragma(mDB, password) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
mDB.serialize(() => {
mDB.run('PRAGMA cipher_compatibility = 4');
mDB.run(`PRAGMA key = '${password}'`, (err) => {
if (err) {
reject(new Error('SetForeignKey: ' + `${err.message}`));
}
resolve();
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
mDB.serialize(() => {
mDB.run('PRAGMA cipher_compatibility = 4');
mDB.run(`PRAGMA key = '${password}'`, (err) => {
if (err) {
reject(new Error('SetForeignKey: ' + `${err.message}`));
}
resolve();
});
});
});
}));
});
}

@@ -77,14 +80,16 @@ /**

setForeignKeyConstraintsEnabled(mDB, toggle) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
var key = 'OFF';
if (toggle) {
key = 'ON';
}
mDB.run(`PRAGMA foreign_keys = '${key}'`, (err) => {
if (err) {
reject(new Error(`SetForeignKey: ${err.message}`));
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
let key = 'OFF';
if (toggle) {
key = 'ON';
}
resolve();
mDB.run(`PRAGMA foreign_keys = '${key}'`, (err) => {
if (err) {
reject(new Error(`SetForeignKey: ${err.message}`));
}
resolve();
});
});
}));
});
}

@@ -96,22 +101,24 @@ /**

getVersion(mDB) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
let version = 0;
const SELECT_VERSION = 'PRAGMA user_version;';
mDB.get(SELECT_VERSION, [], (err, row) => {
// process the row here
if (err) {
reject(new Error('getVersion failed: ' + `${err.message}`));
}
else {
if (row == null) {
version = 0;
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
let version = 0;
const SELECT_VERSION = 'PRAGMA user_version;';
mDB.get(SELECT_VERSION, [], (err, row) => {
// process the row here
if (err) {
reject(new Error('getVersion failed: ' + `${err.message}`));
}
else {
const key = Object.keys(row)[0];
version = row[key];
if (row == null) {
version = 0;
}
else {
const key = Object.keys(row)[0];
version = row[key];
}
resolve(version);
}
resolve(version);
}
});
});
}));
});
}

@@ -124,10 +131,12 @@ /**

setVersion(mDB, version) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
mDB.run(`PRAGMA user_version = ${version}`, (err) => {
if (err) {
reject(new Error('setVersion failed: ' + `${err.message}`));
}
resolve();
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
mDB.run(`PRAGMA user_version = ${version}`, (err) => {
if (err) {
reject(new Error('setVersion failed: ' + `${err.message}`));
}
resolve();
});
});
}));
});
}

@@ -141,5 +150,25 @@ /**

changePassword(pathDB, password, newpassword) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let mDB;
try {
const mDB = yield this.openOrCreateDatabase(pathDB, password);
mDB = yield this.openOrCreateDatabase(pathDB, password);
yield this.pragmaReKey(mDB, password, newpassword);
}
catch (err) {
return Promise.reject(err);
}
finally {
mDB.close();
}
});
}
/**
* PragmaReKey
* @param mDB
* @param password
* @param newpassword
*/
pragmaReKey(mDB, password, newpassword) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
mDB.serialize(() => {

@@ -150,14 +179,9 @@ mDB.run('PRAGMA cipher_compatibility = 4');

if (err) {
mDB.close();
reject(new Error('ChangePassword: ' + `${err.message}`));
}
mDB.close();
resolve();
});
});
}
catch (err) {
reject(new Error(`ChangePassword: ${err.message}`));
}
}));
});
});
}

@@ -170,13 +194,15 @@ /**

beginTransaction(db, isOpen) {
return new Promise((resolve, reject) => {
const msg = 'BeginTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
const sql = 'BEGIN TRANSACTION;';
db.run(sql, (err) => {
if (err) {
reject(new Error(`${msg}${err.message}`));
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
const msg = 'BeginTransaction: ';
if (!isOpen) {
return Promise.reject(new Error(`${msg}database not opened`));
}
resolve();
const sql = 'BEGIN TRANSACTION;';
db.run(sql, (err) => {
if (err) {
reject(new Error(`${msg}${err.message}`));
}
resolve();
});
});

@@ -191,13 +217,15 @@ });

rollbackTransaction(db, isOpen) {
return new Promise((resolve, reject) => {
const msg = 'RollbackTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
const sql = 'ROLLBACK TRANSACTION;';
db.run(sql, (err) => {
if (err) {
reject(new Error(`${msg}${err.message}`));
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
const msg = 'RollbackTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
resolve();
const sql = 'ROLLBACK TRANSACTION;';
db.run(sql, (err) => {
if (err) {
reject(new Error(`${msg}${err.message}`));
}
resolve();
});
});

@@ -212,13 +240,15 @@ });

commitTransaction(db, isOpen) {
return new Promise((resolve, reject) => {
const msg = 'CommitTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
const sql = 'COMMIT TRANSACTION;';
db.run(sql, (err) => {
if (err) {
reject(new Error(`${msg}${err.message}`));
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
const msg = 'CommitTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
resolve();
const sql = 'COMMIT TRANSACTION;';
db.run(sql, (err) => {
if (err) {
reject(new Error(`${msg}${err.message}`));
}
resolve();
});
});

@@ -233,20 +263,22 @@ });

dbChanges(db) {
return new Promise((resolve, reject) => {
const SELECT_CHANGE = 'SELECT total_changes()';
let changes = 0;
db.get(SELECT_CHANGE, [], (err, row) => {
// process the row here
if (err) {
reject(new Error(`DbChanges failed: ${err.message}`));
}
else {
if (row == null) {
changes = 0;
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
const SELECT_CHANGE = 'SELECT total_changes()';
let changes = 0;
db.get(SELECT_CHANGE, [], (err, row) => {
// process the row here
if (err) {
reject(new Error(`DbChanges failed: ${err.message}`));
}
else {
const key = Object.keys(row)[0];
changes = row[key];
if (row == null) {
changes = 0;
}
else {
const key = Object.keys(row)[0];
changes = row[key];
}
resolve(changes);
}
resolve(changes);
}
});
});

@@ -286,3 +318,3 @@ });

execute(mDB, sql) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let changes = -1;

@@ -292,22 +324,30 @@ let initChanges = -1;

initChanges = yield this.dbChanges(mDB);
yield this.execDB(mDB, sql);
changes = (yield this.dbChanges(mDB)) - initChanges;
return Promise.resolve(changes);
}
catch (err) {
reject(new Error(`Execute: ${err.message}`));
return Promise.reject(new Error(`Execute: ${err.message}`));
}
mDB.exec(sql, (err) => __awaiter(this, void 0, void 0, function* () {
if (err) {
const msg = err.message;
reject(new Error(`Execute: ${msg}: `));
}
try {
changes = (yield this.dbChanges(mDB)) - initChanges;
}
catch (err) {
reject(new Error(`ExecuteSQL: ${err.message}`));
}
resolve(changes);
}));
}));
});
}
/**
* ExecDB
* @param mDB
* @param sql
*/
execDB(mDB, sql) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => {
mDB.exec(sql, (err) => __awaiter(this, void 0, void 0, function* () {
if (err) {
const msg = err.message;
reject(new Error(`Execute: ${msg}: `));
}
resolve();
}));
});
});
}
/**
* ExecuteSet

@@ -318,3 +358,3 @@ * @param db

executeSet(db, set) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let lastId = -1;

@@ -327,9 +367,8 @@ for (let i = 0; i < set.length; i++) {

msg += ` or values are null for index ${i}`;
reject(new Error(msg));
break;
return Promise.reject(new Error(msg));
}
try {
if (Array.isArray(values[0])) {
for (let j = 0; j < values.length; j++) {
lastId = yield this.prepareRun(db, statement, values[j]);
for (const val of values) {
lastId = yield this.prepareRun(db, statement, val);
}

@@ -342,8 +381,7 @@ }

catch (err) {
reject(new Error(`ExecuteSet: ${err.message}`));
break;
return Promise.reject(new Error(`ExecuteSet: ${err.message}`));
}
}
resolve(lastId);
}));
return Promise.resolve(lastId);
});
}

@@ -350,0 +388,0 @@ /**

2

electron/dist/esm/electron/src/electron-utils/utilsUpgrade.d.ts

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

import { capSQLiteVersionUpgrade } from '../definitions';
import type { capSQLiteVersionUpgrade } from '../definitions';
export declare class UtilsUpgrade {

@@ -3,0 +3,0 @@ private _uSQLite;

133

electron/dist/esm/electron/src/electron-utils/utilsUpgrade.js
import { __awaiter } from "tslib";
import { UtilsJson } from './ImportExportJson/utilsJson';
import { UtilsDrop } from './utilsDrop';
import { UtilsFile } from './utilsFile';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { UtilsSQLite } from './utilsSQLite';
//1234567890123456789012345678901234567890123456789012345678901234567890
export class UtilsUpgrade {

@@ -25,3 +24,3 @@ constructor() {

onUpgrade(mDB, vUpgDict, dbName, curVersion, targetVersion) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const upgrade = vUpgDict[curVersion];

@@ -31,7 +30,7 @@ if (upgrade != null) {

if (!keys.includes('toVersion')) {
reject(new Error('onUpgrade: toVersion not given'));
return Promise.reject(new Error('onUpgrade: toVersion not given'));
}
const toVersion = upgrade.toVersion;
if (!keys.includes('statement')) {
reject(new Error('onUpgrade: statement not given'));
return Promise.reject(new Error('onUpgrade: statement not given'));
}

@@ -49,3 +48,3 @@ const statement = upgrade.statement;

msg += ` and version ${curVersion}`;
reject(new Error(`onUpgrade: ${msg}`));
return Promise.reject(new Error(`onUpgrade: ${msg}`));
}

@@ -73,12 +72,12 @@ try {

const changes = (yield this._uSQLite.dbChanges(mDB)) - initChanges;
resolve(changes);
return Promise.resolve(changes);
}
catch (err) {
reject(new Error(`onUpgrade: ${err.message}`));
return Promise.reject(new Error(`onUpgrade: ${err.message}`));
}
}
else {
reject(new Error('onUpgrade: upgrade not found'));
return Promise.reject(new Error('onUpgrade: upgrade not found'));
}
}));
});
}

@@ -91,3 +90,3 @@ /**

executeStatementProcess(mDB, statement) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
try {

@@ -104,3 +103,3 @@ // -> backup all existing tables "tableName" in

if (changes < 0) {
reject(new Error('ExecuteStatementProcess: ' + 'changes < 0'));
return Promise.reject(new Error('ExecuteStatementProcess: ' + 'changes < 0'));
}

@@ -118,8 +117,8 @@ // -> Create the list of table's common fields

this._commonColumns = {};
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`ExecuteStatementProcess: ${err.message}`));
return Promise.reject(new Error(`ExecuteStatementProcess: ${err.message}`));
}
}));
});
}

@@ -133,3 +132,3 @@ /**

executeSetProcess(mDB, set, toVersion) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
try {

@@ -139,3 +138,3 @@ // -> load new data

if (lastId < 0) {
reject(new Error('ExecuteSetProcess: lastId ' + '< 0'));
return Promise.reject(new Error('ExecuteSetProcess: lastId ' + '< 0'));
}

@@ -152,11 +151,11 @@ // -> update database version

if (changes < 0) {
reject(new Error('ExecuteSetProcess: changes ' + '< 0'));
return Promise.reject(new Error('ExecuteSetProcess: changes ' + '< 0'));
}
}
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`ExecuteSetProcess: ${err.message}`));
return Promise.reject(new Error(`ExecuteSetProcess: ${err.message}`));
}
}));
});
}

@@ -168,20 +167,20 @@ /**

backupTables(mDB) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
const msg = 'BackupTables: ';
try {
const tables = yield this._uDrop.getTablesNames(mDB);
for (let i = 0; i < tables.length; i++) {
for (const table of tables) {
try {
yield this.backupTable(mDB, tables[i]);
yield this.backupTable(mDB, table);
}
catch (err) {
reject(new Error(`${msg}table ${tables[i]}: ` + `${err.message}`));
return Promise.reject(new Error(`${msg}table ${table}: ` + `${err.message}`));
}
}
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`BackupTables: ${err.message}`));
return Promise.reject(new Error(`BackupTables: ${err.message}`));
}
}));
});
}

@@ -194,3 +193,3 @@ /**

backupTable(mDB, table) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
try {

@@ -214,3 +213,3 @@ // start a transaction

}
reject(new Error(`${msg}`));
return Promise.reject(new Error(`${msg}`));
}

@@ -222,11 +221,11 @@ else {

catch (err) {
reject(new Error('BackupTable: ' + `${err.message}`));
return Promise.reject(new Error('BackupTable: ' + `${err.message}`));
}
}
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error(`BackupTable: ${err.message}`));
return Promise.reject(new Error(`BackupTable: ${err.message}`));
}
}));
});
}

@@ -239,5 +238,5 @@ /**

getTableColumnNames(mDB, tableName) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
let resQuery = [];
let retNames = [];
const retNames = [];
const query = `PRAGMA table_info('${tableName}');`;

@@ -247,12 +246,12 @@ try {

if (resQuery.length > 0) {
for (let i = 0; i < resQuery.length; i++) {
retNames.push(resQuery[i].name);
for (const query of resQuery) {
retNames.push(query.name);
}
}
resolve(retNames);
return Promise.resolve(retNames);
}
catch (err) {
reject(new Error('GetTableColumnNames: ' + `${err.message}`));
return Promise.reject(new Error('GetTableColumnNames: ' + `${err.message}`));
}
}));
});
}

@@ -265,24 +264,22 @@ /**

return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
try {
// Get new table list
const tables = yield this._uDrop.getTablesNames(mDB);
if (tables.length === 0) {
reject(new Error('FindCommonColumns: get ' + "table's names failed"));
try {
// Get new table list
const tables = yield this._uDrop.getTablesNames(mDB);
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 = yield this.getTableColumnNames(mDB, table);
// find the common columns
const keys = Object.keys(this._alterTables);
if (keys.includes(table)) {
this._commonColumns[table] = this.arraysIntersection(this._alterTables[table], tableNames);
}
for (let i = 0; i < tables.length; i++) {
// get the column's name
const tableNames = yield this.getTableColumnNames(mDB, tables[i]);
// find the common columns
const keys = Object.keys(this._alterTables);
if (keys.includes(tables[i])) {
this._commonColumns[tables[i]] = this.arraysIntersection(this._alterTables[tables[i]], tableNames);
}
}
resolve();
}
catch (err) {
reject(new Error(`FindCommonColumns: ${err.message}`));
}
}));
return Promise.resolve();
}
catch (err) {
return Promise.reject(new Error(`FindCommonColumns: ${err.message}`));
}
});

@@ -310,7 +307,7 @@ }

updateNewTablesData(mDB) {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
return __awaiter(this, void 0, void 0, function* () {
try {
// start a transaction
yield this._uSQLite.beginTransaction(mDB, true);
let statements = [];
const statements = [];
const keys = Object.keys(this._commonColumns);

@@ -333,3 +330,3 @@ keys.forEach(key => {

}
reject(new Error(`${msg}`));
return Promise.reject(new Error(`${msg}`));
}

@@ -339,6 +336,6 @@ else {

yield this._uSQLite.commitTransaction(mDB, true);
resolve();
return Promise.resolve();
}
catch (err) {
reject(new Error('updateNewTablesData: ' + `${err.message}`));
return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
}

@@ -348,7 +345,7 @@ }

catch (err) {
reject(new Error('updateNewTablesData: ' + `${err.message}`));
return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
}
}));
});
}
}
//# sourceMappingURL=utilsUpgrade.js.map

20

electron/dist/esm/electron/src/plugin.d.ts
import { WebPlugin } from '@capacitor/core';
import { CapacitorSQLitePlugin, capConnectionOptions, capEchoOptions, capEchoResult, capSQLiteChanges, capSQLiteExecuteOptions, capSQLiteExportOptions, capSQLiteImportOptions, capSQLiteJson, capSQLiteOptions, capSQLiteQueryOptions, capSQLiteResult, capSQLiteRunOptions, capSQLiteSetOptions, capSQLiteSyncDateOptions, capSQLiteUpgradeOptions, capSQLiteValues, capSQLiteSyncDate } from './definitions';
import type { CapacitorSQLitePlugin, capConnectionOptions, capEchoOptions, capEchoResult, capSQLiteChanges, capSQLiteExecuteOptions, capSQLiteExportOptions, capSQLiteImportOptions, capSQLiteJson, capSQLiteOptions, capSQLiteQueryOptions, capSQLiteResult, capSQLiteRunOptions, capSQLiteSetOptions, capSQLiteSyncDateOptions, capSQLiteUpgradeOptions, capSQLiteValues, capSQLiteSyncDate } from './definitions';
export declare class CapacitorSQLiteElectronWeb extends WebPlugin implements CapacitorSQLitePlugin {

@@ -11,7 +11,7 @@ RemoteRef: any;

constructor();
createConnection(options: capConnectionOptions): Promise<capSQLiteResult>;
closeConnection(options: capSQLiteOptions): Promise<capSQLiteResult>;
createConnection(options: capConnectionOptions): Promise<void>;
closeConnection(options: capSQLiteOptions): Promise<void>;
echo(options: capEchoOptions): Promise<capEchoResult>;
open(options: capSQLiteOptions): Promise<capSQLiteResult>;
close(options: capSQLiteOptions): Promise<capSQLiteResult>;
open(options: capSQLiteOptions): Promise<void>;
close(options: capSQLiteOptions): Promise<void>;
execute(options: capSQLiteExecuteOptions): Promise<capSQLiteChanges>;

@@ -22,3 +22,3 @@ executeSet(options: capSQLiteSetOptions): Promise<capSQLiteChanges>;

isDBExists(options: capSQLiteOptions): Promise<capSQLiteResult>;
deleteDatabase(options: capSQLiteOptions): Promise<capSQLiteResult>;
deleteDatabase(options: capSQLiteOptions): Promise<void>;
isJsonValid(options: capSQLiteImportOptions): Promise<capSQLiteResult>;

@@ -28,8 +28,6 @@ importFromJson(options: capSQLiteImportOptions): Promise<capSQLiteChanges>;

createSyncTable(options: capSQLiteOptions): Promise<capSQLiteChanges>;
setSyncDate(options: capSQLiteSyncDateOptions): Promise<capSQLiteResult>;
setSyncDate(options: capSQLiteSyncDateOptions): Promise<void>;
getSyncDate(options: capSQLiteSyncDateOptions): Promise<capSQLiteSyncDate>;
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<capSQLiteResult>;
copyFromAssets(): Promise<capSQLiteResult>;
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<void>;
copyFromAssets(): Promise<void>;
}
declare const CapacitorSQLite: CapacitorSQLiteElectronWeb;
export { CapacitorSQLite };

372

electron/dist/esm/electron/src/plugin.js
import { __awaiter } from "tslib";
import { WebPlugin } from '@capacitor/core';
import { Database } from './electron-utils/Database';
import { UtilsJson } from './electron-utils/ImportExportJson/utilsJson';
import { UtilsFile } from './electron-utils/utilsFile';
import { UtilsJson } from './electron-utils/ImportExportJson/utilsJson';
//1234567890123456789012345678901234567890123456789012345678901234567890
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { remote } = require('electron');

@@ -27,6 +27,3 @@ export class CapacitorSQLiteElectronWeb extends WebPlugin {

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -46,5 +43,5 @@ const dbName = options.database;

}
let mDb = new Database(dbName + 'SQLite.db', encrypted, inMode, version, upgDict);
const mDb = new Database(dbName + 'SQLite.db', encrypted, inMode, version, upgDict);
this._dbDict[dbName] = mDb;
return Promise.resolve({ result: true });
return Promise.resolve();
});

@@ -56,6 +53,3 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -65,8 +59,5 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: 'CloseConnection command failed: No ' +
'available connection for ' +
dbName,
});
return Promise.reject('CloseConnection command failed: No ' +
'available connection for ' +
dbName);
}

@@ -80,10 +71,7 @@ const mDB = this._dbDict[dbName];

catch (err) {
return Promise.resolve({
result: false,
message: 'CloseConnection command failed: ' +
'close ' +
dbName +
' failed ' +
err.message,
});
return Promise.reject('CloseConnection command failed: ' +
'close ' +
dbName +
' failed ' +
err.message);
}

@@ -93,3 +81,3 @@ }

delete this._dbDict[dbName];
return Promise.resolve({ result: true });
return Promise.resolve();
});

@@ -101,3 +89,3 @@ }

ret.value = options.value;
return ret;
return Promise.resolve(ret);
});

@@ -109,6 +97,3 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -118,6 +103,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: `Open: No available connection for ${dbName}`,
});
return Promise.reject(`Open: No available connection for ${dbName}`);
}

@@ -127,9 +109,6 @@ const mDB = this._dbDict[dbName];

yield mDB.open();
return Promise.resolve({ result: true });
return Promise.resolve();
}
catch (err) {
return Promise.resolve({
result: false,
message: `Open: ${err.message}`,
});
return Promise.reject(`Open: ${err.message}`);
}

@@ -142,6 +121,3 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -151,6 +127,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: `Close: No available connection for ${dbName}`,
});
return Promise.reject(`Close: No available connection for ${dbName}`);
}

@@ -160,9 +133,6 @@ const mDB = this._dbDict[dbName];

yield mDB.close();
return Promise.resolve({ result: true });
return Promise.resolve();
}
catch (err) {
return Promise.resolve({
result: false,
message: `Close: ${err.message}`,
});
return Promise.reject(`Close: ${err.message}`);
}

@@ -175,12 +145,6 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('statements') || options.statements.length === 0) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide raw SQL statements',
});
return Promise.reject('Must provide raw SQL statements');
}

@@ -191,6 +155,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1 },
message: `Execute: No available connection for ${dbName}`,
});
return Promise.reject(`Execute: No available connection for ${dbName}`);
}

@@ -201,6 +162,3 @@ const mDB = this._dbDict[dbName];

if (ret < 0) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Execute failed',
});
return Promise.reject('Execute failed changes < 0');
}

@@ -212,6 +170,3 @@ else {

catch (err) {
return Promise.resolve({
changes: { changes: -1 },
message: `Execute failed: ${err}`,
});
return Promise.reject(`Execute failed: ${err}`);
}

@@ -224,12 +179,6 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('set') || options.set.length === 0) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a non-empty set of SQL ' + 'statements',
});
return Promise.reject('Must provide a non-empty set of SQL statements');
}

@@ -240,16 +189,8 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1 },
message: `ExecuteSet: No available connection for ${dbName}`,
});
return Promise.reject(`ExecuteSet: No available connection for ${dbName}`);
}
const mDB = this._dbDict[dbName];
for (let i = 0; i < setOfStatements.length; i++) {
if (!('statement' in setOfStatements[i]) ||
!('values' in setOfStatements[i])) {
return Promise.reject({
changes: { changes: -1 },
message: 'ExecuteSet: Must provide a set as ' +
'Array of {statement,values}',
});
for (const sStmt of setOfStatements) {
if (!('statement' in sStmt) || !('values' in sStmt)) {
return Promise.reject('ExecuteSet: Must provide a set as ' + 'Array of {statement,values}');
}

@@ -260,6 +201,3 @@ }

if (ret < 0) {
return Promise.resolve({
changes: { changes: -1 },
message: `ExecuteSet failed`,
});
return Promise.reject(`ExecuteSet failed changes <0`);
}

@@ -271,6 +209,3 @@ else {

catch (err) {
return Promise.resolve({
changes: { changes: -1 },
message: `ExecuteSet failed: ${err}`,
});
return Promise.reject(`ExecuteSet failed: ${err}`);
}

@@ -283,18 +218,9 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('statement') || options.statement.length === 0) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: 'Must provide a query statement',
});
return Promise.reject('Must provide a query statement');
}
if (!keys.includes('values')) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: 'Must provide an Array of values',
});
return Promise.reject('Must provide an Array of values');
}

@@ -306,6 +232,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: `Run: No available connection for ${dbName}`,
});
return Promise.reject(`Run: No available connection for ${dbName}`);
}

@@ -318,6 +241,3 @@ const mDB = this._dbDict[dbName];

catch (err) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: `RUN failed: ${err} `,
});
return Promise.reject(`RUN failed: ${err} `);
}

@@ -330,18 +250,9 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
values: [],
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('statement') || options.statement.length === 0) {
return Promise.resolve({
values: [],
message: 'Must provide a query statement',
});
return Promise.reject('Must provide a query statement');
}
if (!keys.includes('values')) {
return Promise.resolve({
values: [],
message: 'Must provide an Array of strings',
});
return Promise.reject('Must provide an Array of strings');
}

@@ -353,6 +264,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
values: [],
message: `Query: No available connection for ${dbName}`,
});
return Promise.reject(`Query: No available connection for ${dbName}`);
}

@@ -366,3 +274,3 @@ const mDB = this._dbDict[dbName];

catch (err) {
return Promise.resolve({ values: [], message: `Query failed: ${err}` });
return Promise.reject(`Query failed: ${err}`);
}

@@ -375,6 +283,3 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -384,8 +289,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: 'IsDBExists command failed: No available ' +
'connection for ' +
dbName,
});
return Promise.reject('IsDBExists command failed: No available ' + 'connection for ' + dbName);
}

@@ -402,6 +302,3 @@ const isExists = this._uFile.isFileExists(dbName + 'SQLite.db');

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -411,6 +308,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: 'deleteDatabase: No available connection for ' + `${dbName}`,
});
return Promise.reject('deleteDatabase: No available connection for ' + `${dbName}`);
}

@@ -420,9 +314,6 @@ const mDB = this._dbDict[dbName];

yield mDB.deleteDB(dbName + 'SQLite.db');
return Promise.resolve({ result: true });
return Promise.resolve();
}
catch (err) {
return Promise.resolve({
result: false,
message: `Delete: ${err.message}`,
});
return Promise.reject(`Delete: ${err.message}`);
}

@@ -433,8 +324,5 @@ });

return __awaiter(this, void 0, void 0, function* () {
let keys = Object.keys(options);
const keys = Object.keys(options);
if (!keys.includes('jsonstring')) {
return Promise.resolve({
result: false,
message: 'Must provide a json object',
});
return Promise.reject('Must provide a json object');
}

@@ -445,6 +333,3 @@ const jsonStrObj = options.jsonstring;

if (!isValid) {
return Promise.resolve({
result: false,
message: 'Stringify Json Object not Valid',
});
return Promise.reject('Stringify Json Object not Valid');
}

@@ -459,9 +344,5 @@ else {

return __awaiter(this, void 0, void 0, function* () {
const retRes = { changes: -1 };
let keys = Object.keys(options);
const keys = Object.keys(options);
if (!keys.includes('jsonstring')) {
return Promise.resolve({
changes: retRes,
message: 'Must provide a json object',
});
return Promise.reject('Must provide a json object');
}

@@ -472,6 +353,3 @@ const jsonStrObj = options.jsonstring;

if (!isValid) {
return Promise.resolve({
changes: retRes,
message: 'Must provide a valid JsonSQLite Object',
});
return Promise.reject('Must provide a valid JsonSQLite Object');
}

@@ -484,3 +362,3 @@ const vJsonObj = jsonObj;

// Create the database
let mDb = new Database(dbName, encrypted, mode, dbVersion, {});
const mDb = new Database(dbName, encrypted, mode, dbVersion, {});
try {

@@ -496,6 +374,3 @@ // Open the database

catch (err) {
return Promise.resolve({
changes: retRes,
message: `ImportFromJson: ${err.message}`,
});
return Promise.reject(`ImportFromJson: ${err.message}`);
}

@@ -506,15 +381,8 @@ });

return __awaiter(this, void 0, void 0, function* () {
let retRes = {};
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
export: retRes,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('jsonexportmode')) {
return Promise.resolve({
export: retRes,
message: 'Must provide a json export mode',
});
return Promise.reject('Must provide a json export mode');
}

@@ -525,6 +393,3 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
export: retRes,
message: 'exportToJson: No available connection for ' + `${dbName}`,
});
return Promise.reject('exportToJson: No available connection for ' + `${dbName}`);
}

@@ -536,6 +401,3 @@ const mDB = this._dbDict[dbName];

if (keys.includes('message')) {
return Promise.resolve({
export: retRes,
message: `exportToJson: ${ret.message}`,
});
return Promise.reject(`exportToJson: ${ret.message}`);
}

@@ -547,6 +409,3 @@ else {

catch (err) {
return Promise.resolve({
export: retRes,
message: `exportToJson: ${err.message}`,
});
return Promise.reject(`exportToJson: ${err.message}`);
}

@@ -559,6 +418,3 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -568,14 +424,11 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1 },
message: 'CreateSyncTable: No available connection for ' + `${dbName}`,
});
return Promise.reject('CreateSyncTable: No available connection for ' + `${dbName}`);
}
const mDB = this._dbDict[dbName];
const ret = yield mDB.createSyncTable();
if (ret.message === null) {
return Promise.resolve({ changes: ret.changes });
try {
const ret = yield mDB.createSyncTable();
return Promise.resolve({ changes: { changes: ret } });
}
else {
return Promise.resolve({ changes: ret.changes, message: ret.message });
catch (err) {
return Promise.reject(`createSyncTable: ${err.message}`);
}

@@ -588,12 +441,6 @@ });

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('syncdate')) {
return Promise.resolve({
result: false,
message: 'Must provide a synchronization date',
});
return Promise.reject('Must provide a synchronization date');
}

@@ -604,11 +451,12 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: `SetSyncDate: No available connection for ${dbName}`,
});
return Promise.reject(`SetSyncDate: No available connection for ${dbName}`);
}
const mDB = this._dbDict[dbName];
const ret = yield mDB.setSyncDate(syncDate);
console.log(`$$$ setSyncDate ${JSON.stringify(ret)}`);
return Promise.resolve(ret);
try {
yield mDB.setSyncDate(syncDate);
return Promise.resolve();
}
catch (err) {
return Promise.reject(`SetSyncDate: ${err.message}`);
}
});

@@ -620,6 +468,3 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
syncDate: 0,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}

@@ -629,10 +474,12 @@ const dbName = options.database;

if (!keys.includes(dbName)) {
return Promise.resolve({
syncDate: 0,
message: `GetSyncDate: No available connection for ${dbName}`,
});
return Promise.reject(`GetSyncDate: No available connection for ${dbName}`);
}
const mDB = this._dbDict[dbName];
const ret = yield mDB.getSyncDate();
return Promise.resolve(ret);
try {
const ret = yield mDB.getSyncDate();
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(`GetSyncDate: ${err.message}`);
}
});

@@ -644,12 +491,6 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('upgrade')) {
return Promise.resolve({
result: false,
message: 'Must provide an upgrade statement',
});
return Promise.reject('Must provide an upgrade statement');
}

@@ -662,12 +503,6 @@ const dbName = options.database;

!keys.includes('statement')) {
return Promise.reject({
result: false,
message: 'Must provide an upgrade ' + 'capSQLiteVersionUpgrade Object',
});
return Promise.reject('Must provide an upgrade capSQLiteVersionUpgrade Object');
}
if (typeof upgrade.fromVersion != 'number') {
return Promise.reject({
result: false,
message: 'ugrade.fromVersion must be a number',
});
return Promise.reject('ugrade.fromVersion must be a number');
}

@@ -677,3 +512,3 @@ const upgVDict = {};

this._versionUpgrades[dbName] = upgVDict;
return Promise.resolve({ result: true });
return Promise.resolve();
});

@@ -694,3 +529,3 @@ }

// for each check if the suffix SQLite.db is there or add it
let toDb = this._uFile.setPathSuffix(db);
const toDb = this._uFile.setPathSuffix(db);
toDbList.push(toDb);

@@ -700,9 +535,6 @@ // for each copy the file to the Application database folder

}));
return Promise.resolve({ result: true });
return Promise.resolve();
}
else {
return Promise.resolve({
result: false,
message: 'CopyFromAssets: assets/databases folder does not exist',
});
return Promise.reject('CopyFromAssets: assets/databases folder does not exist');
}

@@ -712,6 +544,2 @@ });

}
const CapacitorSQLite = new CapacitorSQLiteElectronWeb();
export { CapacitorSQLite };
import { registerWebPlugin } from '@capacitor/core';
registerWebPlugin(CapacitorSQLite);
//# sourceMappingURL=plugin.js.map

130

electron/dist/esm/src/definitions.d.ts

@@ -13,13 +13,13 @@ declare module '@capacitor/core' {

* @param options capConnectionOptions
* @return Promise<capSQLiteResult>
* @return Promise<void>
* @since 2.9.0 refactor
*/
createConnection(options: capConnectionOptions): Promise<capSQLiteResult>;
createConnection(options: capConnectionOptions): Promise<void>;
/**
* close a database connection
* @param options capSQLiteOptions
* @return Promise<capSQLiteResult>
* @return Promise<void>
* @since 2.9.0 refactor
*/
closeConnection(options: capSQLiteOptions): Promise<capSQLiteResult>;
closeConnection(options: capSQLiteOptions): Promise<void>;
/**

@@ -36,13 +36,13 @@ * Echo a given string

* @param options: capSQLiteOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 0.0.1
*/
open(options: capSQLiteOptions): Promise<capSQLiteResult>;
open(options: capSQLiteOptions): Promise<void>;
/**
* Close a SQLite database
* @param options: capSQLiteOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 0.0.1
*/
close(options: capSQLiteOptions): Promise<capSQLiteResult>;
close(options: capSQLiteOptions): Promise<void>;
/**

@@ -86,6 +86,6 @@ * Execute a Batch of Raw Statements as String

* @param options: capSQLiteOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 0.0.1
*/
deleteDatabase(options: capSQLiteOptions): Promise<capSQLiteResult>;
deleteDatabase(options: capSQLiteOptions): Promise<void>;
/**

@@ -122,6 +122,6 @@ * Is Json Object Valid

* @param options: capSQLiteSyncDateOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.0.1-1
*/
setSyncDate(options: capSQLiteSyncDateOptions): Promise<capSQLiteResult>;
setSyncDate(options: capSQLiteSyncDateOptions): Promise<void>;
/**

@@ -137,13 +137,13 @@ * Get the synchronization date

* @param options: capSQLiteUpgradeOptions
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.4.2-6 iOS & Electron 2.4.2-7 Android
*/
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<capSQLiteResult>;
addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<void>;
/**
* Copy databases from public/assets/databases folder to application databases folder
*
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
copyFromAssets(): Promise<capSQLiteResult>;
copyFromAssets(): Promise<void>;
}

@@ -291,6 +291,2 @@ export interface capEchoOptions {

result?: boolean;
/**
* a returned message
*/
message?: string;
}

@@ -302,6 +298,2 @@ export interface capSQLiteChanges {

changes?: Changes;
/**
* a returned message
*/
message?: string;
}

@@ -323,6 +315,2 @@ export interface Changes {

values?: any[];
/**
* a returned message
*/
message?: string;
}

@@ -334,6 +322,2 @@ export interface capSQLiteJson {

export?: JsonSQLite;
/**
* a returned message
*/
message?: string;
}

@@ -345,6 +329,2 @@ export interface capSQLiteSyncDate {

syncDate?: number;
/**
* a returned message
*/
message?: string;
}

@@ -449,6 +429,6 @@ export interface JsonSQLite {

* @param set
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<capSQLiteResult>;
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<void>;
/**

@@ -460,16 +440,16 @@ * Create a connection to a database

* @param version
* @returns Promise<SQLiteDBConnection | null>
* @returns Promise<SQLiteDBConnection>
* @since 2.9.0 refactor
*/
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection | null>;
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection>;
/**
* Retrieve an existing database connection
* @param database
* @returns Promise<capSQLiteResult>
* @returns Promise<SQLiteDBConnection>
* @since 2.9.0 refactor
*/
retrieveConnection(database: string): Promise<SQLiteDBConnection | null | undefined>;
retrieveConnection(database: string): Promise<SQLiteDBConnection>;
/**
* Retrieve all database connections
* @returns Promise<capSQLiteResult>
* @returns Promise<Map<string, SQLiteDBConnection>>
* @since 2.9.0 refactor

@@ -481,12 +461,12 @@ */

* @param database
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
closeConnection(database: string): Promise<capSQLiteResult>;
closeConnection(database: string): Promise<void>;
/**
* Close all database connections
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
closeAllConnections(): Promise<capSQLiteResult>;
closeAllConnections(): Promise<void>;
/**

@@ -508,6 +488,6 @@ * Import a database From a JSON

* Copy databases from public/assets/databases folder to application databases folder
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
copyFromAssets(): Promise<capSQLiteResult>;
copyFromAssets(): Promise<void>;
}

@@ -522,11 +502,11 @@ /**

echo(value: string): Promise<capEchoResult>;
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<capSQLiteResult>;
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection | null>;
closeConnection(database: string): Promise<capSQLiteResult>;
retrieveConnection(database: string): Promise<SQLiteDBConnection | null | undefined>;
addUpgradeStatement(database: string, fromVersion: number, toVersion: number, statement: string, set?: capSQLiteSet[]): Promise<void>;
createConnection(database: string, encrypted: boolean, mode: string, version: number): Promise<SQLiteDBConnection>;
closeConnection(database: string): Promise<void>;
retrieveConnection(database: string): Promise<SQLiteDBConnection>;
retrieveAllConnections(): Promise<Map<string, SQLiteDBConnection>>;
closeAllConnections(): Promise<capSQLiteResult>;
closeAllConnections(): Promise<void>;
importFromJson(jsonstring: string): Promise<capSQLiteChanges>;
isJsonValid(jsonstring: string): Promise<capSQLiteResult>;
copyFromAssets(): Promise<capSQLiteResult>;
copyFromAssets(): Promise<void>;
}

@@ -539,3 +519,3 @@ /**

* Get SQLite DB Connection DB name
* @returns Promise<string>
* @returns string
* @since 2.9.0 refactor

@@ -546,12 +526,12 @@ */

* Open a SQLite DB Connection
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
open(): Promise<capSQLiteResult>;
open(): Promise<void>;
/**
* Close a SQLite DB Connection
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
close(): Promise<capSQLiteResult>;
close(): Promise<void>;
/**

@@ -571,3 +551,3 @@ * Execute SQLite DB Connection Statements

*/
query(statement: string, values?: Array<string>): Promise<capSQLiteValues>;
query(statement: string, values?: string[]): Promise<capSQLiteValues>;
/**

@@ -580,3 +560,3 @@ * Execute SQLite DB Connection Raw Statement

*/
run(statement: string, values?: Array<any>): Promise<capSQLiteChanges>;
run(statement: string, values?: any[]): Promise<capSQLiteChanges>;
/**

@@ -588,3 +568,3 @@ * Execute SQLite DB Connection Set

*/
executeSet(set: Array<capSQLiteSet>): Promise<capSQLiteChanges>;
executeSet(set: capSQLiteSet[]): Promise<capSQLiteChanges>;
/**

@@ -598,9 +578,9 @@ * Check if a SQLite DB Connection exists

* Delete a SQLite DB Connection
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
delete(): Promise<capSQLiteResult>;
delete(): Promise<void>;
/**
* Create a synchronization table
* @returns Promise<capSQLiteResult>
* @returns Promise<capSQLiteChanges>
* @since 2.9.0 refactor

@@ -612,6 +592,6 @@ */

* @param syncdate
* @returns Promise<capSQLiteResult>
* @returns Promise<void>
* @since 2.9.0 refactor
*/
setSyncDate(syncdate: string): Promise<capSQLiteResult>;
setSyncDate(syncdate: string): Promise<void>;
/**

@@ -639,14 +619,14 @@ * Get the synchronization date

getConnectionDBName(): string;
open(): Promise<capSQLiteResult>;
close(): Promise<capSQLiteResult>;
open(): Promise<void>;
close(): Promise<void>;
execute(statements: string): Promise<capSQLiteChanges>;
query(statement: string, values?: Array<string>): Promise<capSQLiteValues>;
run(statement: string, values?: Array<any>): Promise<capSQLiteChanges>;
executeSet(set: Array<capSQLiteSet>): Promise<capSQLiteChanges>;
query(statement: string, values?: string[]): Promise<capSQLiteValues>;
run(statement: string, values?: any[]): Promise<capSQLiteChanges>;
executeSet(set: capSQLiteSet[]): Promise<capSQLiteChanges>;
isExists(): Promise<capSQLiteResult>;
delete(): Promise<capSQLiteResult>;
delete(): Promise<void>;
createSyncTable(): Promise<capSQLiteChanges>;
setSyncDate(syncdate: string): Promise<capSQLiteResult>;
setSyncDate(syncdate: string): Promise<void>;
getSyncDate(): Promise<capSQLiteSyncDate>;
exportToJson(mode: string): Promise<capSQLiteJson>;
}

295

electron/dist/esm/src/definitions.js

@@ -17,3 +17,3 @@ import { __awaiter } from "tslib";

return __awaiter(this, void 0, void 0, function* () {
let upgrade = {
const upgrade = {
fromVersion,

@@ -24,7 +24,12 @@ toVersion,

};
const res = yield this.sqlite.addUpgradeStatement({
database,
upgrade: [upgrade],
});
return res;
try {
yield this.sqlite.addUpgradeStatement({
database,
upgrade: [upgrade],
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});

@@ -34,15 +39,15 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.createConnection({
database,
encrypted,
mode,
version,
});
if (res.result) {
try {
yield this.sqlite.createConnection({
database,
encrypted,
mode,
version,
});
const conn = new SQLiteDBConnection(database, this.sqlite);
this._connectionDict.set(database, conn);
return conn;
return Promise.resolve(conn);
}
else {
return null;
catch (err) {
return Promise.reject(err);
}

@@ -53,7 +58,10 @@ });

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.closeConnection({ database });
if (res.result) {
try {
yield this.sqlite.closeConnection({ database });
this._connectionDict.delete(database);
return Promise.resolve();
}
return res;
catch (err) {
return Promise.reject(err);
}
});

@@ -63,6 +71,13 @@ }

return __awaiter(this, void 0, void 0, function* () {
const conn = this._connectionDict.has(database)
? this._connectionDict.get(database)
: null;
return conn;
if (this._connectionDict.has(database)) {
const conn = this._connectionDict.get(database);
if (typeof conn != 'undefined')
return Promise.resolve(conn);
else {
return Promise.reject(`Connection ${database} is undefined`);
}
}
else {
return Promise.reject(`Connection ${database} does not exist`);
}
});

@@ -78,13 +93,15 @@ }

const delDict = new Map();
let res;
for (let database of this._connectionDict.keys()) {
res = yield this.sqlite.closeConnection({ database });
if (!res.result)
break;
delDict.set(database, null);
try {
for (const database of this._connectionDict.keys()) {
yield this.sqlite.closeConnection({ database });
delDict.set(database, null);
}
for (const database of delDict.keys()) {
this._connectionDict.delete(database);
}
return Promise.resolve();
}
for (let database of delDict.keys()) {
this._connectionDict.delete(database);
catch (err) {
return Promise.reject(err);
}
return res;
});

@@ -94,3 +111,9 @@ }

return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.importFromJson({ jsonstring: jsonstring });
try {
const ret = yield this.sqlite.importFromJson({ jsonstring: jsonstring });
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -100,3 +123,9 @@ }

return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.isJsonValid({ jsonstring: jsonstring });
try {
const ret = yield this.sqlite.isJsonValid({ jsonstring: jsonstring });
return Promise.resolve(ret);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -106,3 +135,9 @@ }

return __awaiter(this, void 0, void 0, function* () {
return yield this.sqlite.copyFromAssets();
try {
yield this.sqlite.copyFromAssets();
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});

@@ -126,4 +161,9 @@ }

console.log('>>> in SQLiteDBConnection open dbName ' + this.dbName);
const res = yield this.sqlite.open({ database: this.dbName });
return res;
try {
yield this.sqlite.open({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});

@@ -133,4 +173,9 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.close({ database: this.dbName });
return res;
try {
yield this.sqlite.close({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});

@@ -140,7 +185,12 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.execute({
database: this.dbName,
statements: statements,
});
return res;
try {
const res = yield this.sqlite.execute({
database: this.dbName,
statements: statements,
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -151,17 +201,22 @@ }

let res;
if (values && values.length > 0) {
res = yield this.sqlite.query({
database: this.dbName,
statement: statement,
values: values,
});
try {
if (values && values.length > 0) {
res = yield this.sqlite.query({
database: this.dbName,
statement: statement,
values: values,
});
}
else {
res = yield this.sqlite.query({
database: this.dbName,
statement: statement,
values: [],
});
}
return Promise.resolve(res);
}
else {
res = yield this.sqlite.query({
database: this.dbName,
statement: statement,
values: [],
});
catch (err) {
return Promise.reject(err);
}
return res;
});

@@ -172,17 +227,22 @@ }

let res;
if (values && values.length > 0) {
res = yield this.sqlite.run({
database: this.dbName,
statement: statement,
values: values,
});
try {
if (values && values.length > 0) {
res = yield this.sqlite.run({
database: this.dbName,
statement: statement,
values: values,
});
}
else {
res = yield this.sqlite.run({
database: this.dbName,
statement: statement,
values: [],
});
}
return Promise.resolve(res);
}
else {
res = yield this.sqlite.run({
database: this.dbName,
statement: statement,
values: [],
});
catch (err) {
return Promise.reject(err);
}
return res;
});

@@ -192,7 +252,12 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.executeSet({
database: this.dbName,
set: set,
});
return res;
try {
const res = yield this.sqlite.executeSet({
database: this.dbName,
set: set,
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -202,6 +267,11 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.isDBExists({
database: this.dbName,
});
return res;
try {
const res = yield this.sqlite.isDBExists({
database: this.dbName,
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -211,6 +281,9 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.deleteDatabase({
database: this.dbName,
});
return res;
try {
yield this.sqlite.deleteDatabase({ database: this.dbName });
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});

@@ -220,6 +293,11 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.createSyncTable({
database: this.dbName,
});
return res;
try {
const res = yield this.sqlite.createSyncTable({
database: this.dbName,
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -229,7 +307,12 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.setSyncDate({
database: this.dbName,
syncdate: syncdate,
});
return res;
try {
yield this.sqlite.setSyncDate({
database: this.dbName,
syncdate: syncdate,
});
return Promise.resolve();
}
catch (err) {
return Promise.reject(err);
}
});

@@ -239,6 +322,11 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.getSyncDate({
database: this.dbName,
});
return res;
try {
const res = yield this.sqlite.getSyncDate({
database: this.dbName,
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -248,7 +336,12 @@ }

return __awaiter(this, void 0, void 0, function* () {
const res = yield this.sqlite.exportToJson({
database: this.dbName,
jsonexportmode: mode,
});
return res;
try {
const res = yield this.sqlite.exportToJson({
database: this.dbName,
jsonexportmode: mode,
});
return Promise.resolve(res);
}
catch (err) {
return Promise.reject(err);
}
});

@@ -255,0 +348,0 @@ }

472

electron/src/electron-utils/Database.ts

@@ -0,11 +1,11 @@

import { GlobalSQLite } from '../GlobalSQLite';
import type { capSQLiteVersionUpgrade, JsonSQLite } from '../definitions';
import { ExportToJson } from './ImportExportJson/exportToJson';
import { ImportFromJson } from './ImportExportJson/importFromJson';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { UtilsEncryption } from './utilsEncryption';
import { UtilsFile } from './utilsFile';
import { UtilsSQLite } from './utilsSQLite';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { GlobalSQLite } from '../GlobalSQLite';
import { UtilsEncryption } from './utilsEncryption';
import { UtilsUpgrade } from './utilsUpgrade';
import { ImportFromJson } from './ImportExportJson/importFromJson';
import { ExportToJson } from './ImportExportJson/exportToJson';
import { capSQLiteVersionUpgrade, JsonSQLite } from '../definitions';
//1234567890123456789012345678901234567890123456789012345678901234567890

@@ -65,62 +65,56 @@ export class Database {

async open(): Promise<void> {
return new Promise(async (resolve, reject) => {
this._isDBOpen = false;
let password: string = '';
try {
if (
this._encrypted &&
(this._mode === 'secret' || this._mode === 'encryption')
) {
password = this._uGlobal.secret;
}
if (this._mode === 'newsecret') {
// change the password
const oPassword: string = this._uGlobal.secret;
const nPassword: string = this._uGlobal.newsecret;
await this._uSQLite.changePassword(
this._pathDB,
oPassword,
nPassword,
);
password = nPassword;
}
this._isDBOpen = false;
let password = '';
try {
if (
this._encrypted &&
(this._mode === 'secret' || this._mode === 'encryption')
) {
password = this._uGlobal.secret;
}
if (this._mode === 'newsecret') {
// change the password
const oPassword: string = this._uGlobal.secret;
const nPassword: string = this._uGlobal.newsecret;
await this._uSQLite.changePassword(this._pathDB, oPassword, nPassword);
password = nPassword;
}
if (this._mode === 'encryption') {
await this._uEncrypt.encryptDatabase(this._pathDB, password);
}
this._mDB = await this._uSQLite.openOrCreateDatabase(
this._pathDB,
password,
);
if (this._mode === 'encryption') {
await this._uEncrypt.encryptDatabase(this._pathDB, password);
}
this._mDB = await this._uSQLite.openOrCreateDatabase(
this._pathDB,
password,
);
let curVersion: number = await this._uSQLite.getVersion(this._mDB);
this._isDBOpen = true;
const curVersion: number = await this._uSQLite.getVersion(this._mDB);
this._isDBOpen = true;
if (this._version > curVersion) {
if (this._version > curVersion) {
try {
// execute the upgrade flow process
await this._uUpg.onUpgrade(
this._mDB,
this._vUpgDict,
this._dbName,
curVersion,
this._version,
);
// delete the backup database
await this._uFile.deleteFileName(`backup-${this._dbName}`);
} catch (err) {
// restore the database from backup
try {
// execute the upgrade flow process
await this._uUpg.onUpgrade(
this._mDB,
this._vUpgDict,
this._dbName,
curVersion,
this._version,
);
// delete the backup database
await this._uFile.deleteFileName(`backup-${this._dbName}`);
await this._uFile.restoreFileName(this._dbName, 'backup');
} catch (err) {
// restore the database from backup
try {
await this._uFile.restoreFileName(this._dbName, 'backup');
} catch (err) {
reject(new Error(`Open: ${err.message}`));
}
return Promise.reject(new Error(`Open: ${err.message}`));
}
}
resolve();
} catch (err) {
if (this._isDBOpen) this.close();
reject(new Error(`Open: ${err.message}`));
}
});
return Promise.resolve();
} catch (err) {
if (this._isDBOpen) this.close();
return Promise.reject(new Error(`Open: ${err.message}`));
}
}

@@ -133,16 +127,14 @@ /**

async close(): Promise<void> {
return new Promise(async (resolve, reject) => {
if (this._mDB != null && this._isDBOpen) {
this._mDB.close((err: Error) => {
if (err) {
let msg: string = 'Close: Failed in closing: ';
msg += `${this._dbName} ${err.message}`;
reject(new Error(msg));
}
this._isDBOpen = false;
resolve();
});
}
resolve();
});
if (this._mDB != null && this._isDBOpen) {
this._mDB.close((err: Error) => {
if (err) {
let msg = 'Close: Failed in closing: ';
msg += `${this._dbName} ${err.message}`;
return Promise.reject(new Error(msg));
}
this._isDBOpen = false;
return Promise.resolve();
});
}
return Promise.resolve();
}

@@ -156,31 +148,29 @@ /**

async deleteDB(dbName: string): Promise<void> {
return new Promise(async (resolve, reject) => {
// test if file exists
const isExists: boolean = this._uFile.isFileExists(dbName);
if (isExists && !this._isDBOpen) {
// open the database
try {
await this.open();
} catch (err) {
reject(new Error(`DeleteDB: ${err.message}`));
}
// test if file exists
const isExists: boolean = this._uFile.isFileExists(dbName);
if (isExists && !this._isDBOpen) {
// open the database
try {
await this.open();
} catch (err) {
return Promise.reject(new Error(`DeleteDB: ${err.message}`));
}
// close the database
}
// close the database
try {
await this.close();
} catch (err) {
return Promise.reject(new Error('DeleteDB: Close failed'));
}
// delete the database
if (isExists) {
try {
await this.close();
await this._uFile.deleteFileName(dbName);
} catch (err) {
reject(new Error('DeleteDB: Close failed'));
let msg = `DeleteDB: deleteFile ${dbName}`;
msg += ` failed ${err.message}`;
return Promise.reject(new Error(msg));
}
// delete the database
if (isExists) {
try {
await this._uFile.deleteFileName(dbName);
} catch (err) {
let msg: string = `DeleteDB: deleteFile ${dbName}`;
msg += ` failed ${err.message}`;
reject(new Error(msg));
}
}
resolve();
});
}
return Promise.resolve();
}

@@ -190,12 +180,12 @@ /**

* create the synchronization table
* @returns Promise<{result: boolean, message: string}>
* @returns Promise<number>
*/
async createSyncTable(): Promise<any> {
async createSyncTable(): Promise<number> {
if (!this._isDBOpen) {
let msg = `CreateSyncTable: Database ${this._dbName} `;
msg += `not opened`;
return { result: false, message: msg };
return Promise.reject(new Error(msg));
}
let changes: number = -1;
let isOpen = this._isDBOpen;
let changes = -1;
const isOpen = this._isDBOpen;
// check if the table has already being created

@@ -219,8 +209,10 @@ try {

if (changes < 0) {
return { changes: -1, message: `CreateSyncTable failed` };
return Promise.reject(
new Error(`CreateSyncTable: failed changes < 0`),
);
}
}
return { changes: changes };
return Promise.resolve(changes);
} catch (err) {
return { changes: -1, message: `CreateSyncTable: ${err.message}` };
return Promise.reject(new Error(`CreateSyncTable: ${err.message}`));
}

@@ -242,3 +234,3 @@ }

const sDate: number = Math.round(new Date(syncDate).getTime() / 1000);
let stmt: string = `UPDATE sync_table SET sync_date = `;
let stmt = `UPDATE sync_table SET sync_date = `;
stmt += `${sDate} WHERE id = 1;`;

@@ -286,26 +278,24 @@ console.log(`>>> setSyncDate stmt ${stmt}`);

async executeSQL(sql: string): Promise<number> {
return new Promise(async (resolve, reject) => {
if (!this._isDBOpen) {
let msg = `ExecuteSQL: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
if (!this._isDBOpen) {
let msg = `ExecuteSQL: Database ${this._dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
const changes = await this._uSQLite.execute(this._mDB, sql);
if (changes < 0) {
return Promise.reject(new Error('ExecuteSQL: changes < 0'));
}
await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
return Promise.resolve(changes);
} catch (err) {
let msg = `ExecuteSQL: ${err.message}`;
try {
await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
const changes = await this._uSQLite.execute(this._mDB, sql);
if (changes < 0) {
reject(new Error('ExecuteSQL: changes < 0'));
}
await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
resolve(changes);
await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
} catch (err) {
let msg: string = `ExecuteSQL: ${err.message}`;
try {
await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
} catch (err) {
msg += ` : ${err.message}`;
}
reject(new Error(`ExecuteSQL: ${msg}`));
msg += ` : ${err.message}`;
}
});
return Promise.reject(new Error(`ExecuteSQL: ${msg}`));
}
}

@@ -320,15 +310,13 @@ /**

async selectSQL(sql: string, values: string[]): Promise<any[]> {
return new Promise(async (resolve, reject) => {
if (!this._isDBOpen) {
let msg = `SelectSQL: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
}
try {
const retArr = await this._uSQLite.queryAll(this._mDB, sql, values);
resolve(retArr);
} catch (err) {
reject(new Error(`SelectSQL: ${err.message}`));
}
});
if (!this._isDBOpen) {
let msg = `SelectSQL: Database ${this._dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
try {
const retArr = await this._uSQLite.queryAll(this._mDB, sql, values);
return Promise.resolve(retArr);
} catch (err) {
return Promise.reject(new Error(`SelectSQL: ${err.message}`));
}
}

@@ -343,38 +331,38 @@ /**

async runSQL(statement: string, values: any[]): Promise<any> {
return new Promise(async (resolve, reject) => {
if (!this._isDBOpen) {
let msg = `RunSQL: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
if (!this._isDBOpen) {
let msg = `RunSQL: Database ${this._dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
const retRes: any = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
initChanges = await this._uSQLite.dbChanges(this._mDB);
// start a transaction
await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
} catch (err) {
return Promise.reject(new Error(`RunSQL: ${err.message}`));
}
this._mDB.run(statement, values, async (err: Error) => {
if (err) {
const msg: string = err.message;
try {
await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
return Promise.reject(new Error(`RunSQL: ${err.message}`));
} catch (err) {
return Promise.reject(
new Error(`RunSQL: ${msg}: ` + `${err.message}`),
);
}
} else {
try {
await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes =
(await this._uSQLite.dbChanges(this._mDB)) - initChanges;
retRes.lastId = await this._uSQLite.getLastId(this._mDB);
return Promise.resolve(retRes);
} catch (err) {
return Promise.reject(new Error(`RunSQL: ${err.message}`));
}
}
let retRes: any = { changes: -1, lastId: -1 };
let initChanges: number = -1;
try {
initChanges = await this._uSQLite.dbChanges(this._mDB);
// start a transaction
await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
} catch (err) {
reject(new Error(`RunSQL: ${err.message}`));
}
this._mDB.run(statement, values, async (err: Error) => {
if (err) {
const msg: string = err.message;
try {
await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
reject(new Error(`RunSQL: ${err.message}`));
} catch (err) {
reject(new Error(`RunSQL: ${msg}: ` + `${err.message}`));
}
} else {
try {
await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes =
(await this._uSQLite.dbChanges(this._mDB)) - initChanges;
retRes.lastId = await this._uSQLite.getLastId(this._mDB);
resolve(retRes);
} catch (err) {
reject(new Error(`RunSQL: ${err.message}`));
}
}
});
});

@@ -389,83 +377,75 @@ }

async execSet(set: any[]): Promise<any> {
return new Promise(async (resolve, reject) => {
if (!this._isDBOpen) {
let msg = `ExecSet: Database ${this._dbName} `;
msg += `not opened`;
reject(new Error(msg));
}
let retRes: any = { changes: -1, lastId: -1 };
let initChanges: number = -1;
if (!this._isDBOpen) {
let msg = `ExecSet: Database ${this._dbName} `;
msg += `not opened`;
return Promise.reject(new Error(msg));
}
const retRes: any = { changes: -1, lastId: -1 };
let initChanges = -1;
try {
initChanges = await this._uSQLite.dbChanges(this._mDB);
// start a transaction
await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
} catch (err) {
return Promise.reject(new Error(`ExecSet: ${err.message}`));
}
try {
retRes.lastId = await this._uSQLite.executeSet(this._mDB, set);
await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes = (await this._uSQLite.dbChanges(this._mDB)) - initChanges;
return Promise.resolve(retRes);
} catch (err) {
const msg: string = err.message;
try {
initChanges = await this._uSQLite.dbChanges(this._mDB);
// start a transaction
await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
} catch (err) {
reject(new Error(`ExecSet: ${err.message}`));
return Promise.reject(
new Error(`ExecSet: ${msg}: ` + `${err.message}`),
);
}
}
}
public async importJson(jsonData: JsonSQLite): Promise<number> {
let changes = -1;
if (this._isDBOpen) {
try {
retRes.lastId = await this._uSQLite.executeSet(this._mDB, set);
await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
retRes.changes =
(await this._uSQLite.dbChanges(this._mDB)) - initChanges;
resolve(retRes);
// create the database schema
changes = await this._iFJson.createDatabaseSchema(this._mDB, jsonData);
if (changes != -1) {
// create the tables data
changes = await this._iFJson.createTablesData(this._mDB, jsonData);
}
return Promise.resolve(changes);
} catch (err) {
const msg: string = err.message;
try {
await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
} catch (err) {
reject(new Error(`ExecSet: ${msg}: ` + `${err.message}`));
}
return Promise.reject(new Error(`ImportJson: ${err.message}`));
}
});
} else {
return Promise.reject(new Error(`ImportJson: database is closed`));
}
}
public importJson(jsonData: JsonSQLite): Promise<number> {
return new Promise(async (resolve, reject) => {
let changes: number = -1;
if (this._isDBOpen) {
try {
// create the database schema
changes = await this._iFJson.createDatabaseSchema(
this._mDB,
jsonData,
);
if (changes != -1) {
// create the tables data
changes = await this._iFJson.createTablesData(this._mDB, jsonData);
}
resolve(changes);
} catch (err) {
reject(new Error(`ImportJson: ${err.message}`));
public async exportJson(mode: string): Promise<any> {
const inJson: JsonSQLite = {} as JsonSQLite;
inJson.database = this._dbName.slice(0, -9);
inJson.version = this._version;
inJson.encrypted = false;
inJson.mode = mode;
if (this._isDBOpen) {
try {
const retJson: JsonSQLite = await this._eTJson.createExportObject(
this._mDB,
inJson,
);
const isValid = this._uJson.isJsonSQLite(retJson);
if (isValid) {
return Promise.resolve(retJson);
} else {
return Promise.reject(new Error(`ExportJson: retJson not valid`));
}
} else {
reject(new Error(`ImportJson: database is closed`));
} catch (err) {
return Promise.reject(new Error(`ExportJson: ${err.message}`));
}
});
} else {
return Promise.reject(new Error(`ExportJson: database is closed`));
}
}
public exportJson(mode: string): Promise<any> {
return new Promise(async (resolve, reject) => {
const inJson: JsonSQLite = {} as JsonSQLite;
inJson.database = this._dbName.slice(0, -9);
inJson.version = this._version;
inJson.encrypted = false;
inJson.mode = mode;
if (this._isDBOpen) {
try {
const retJson: JsonSQLite = await this._eTJson.createExportObject(
this._mDB,
inJson,
);
const isValid = this._uJson.isJsonSQLite(retJson);
if (isValid) {
resolve(retJson);
} else {
reject(new Error(`ExportJson: retJson not valid`));
}
} catch (err) {
reject(new Error(`ExportJson: ${err.message}`));
}
} else {
reject(new Error(`ExportJson: database is closed`));
}
});
}
}

841

electron/src/electron-utils/ImportExportJson/exportToJson.ts

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

import {
import type {
JsonSQLite,

@@ -8,2 +8,3 @@ JsonTable,

import { UtilsSQLite } from '../utilsSQLite';
import { UtilsJson } from './utilsJson';

@@ -19,44 +20,47 @@

*/
public createExportObject(mDB: any, sqlObj: JsonSQLite): Promise<JsonSQLite> {
return new Promise(async (resolve, reject) => {
let retObj: JsonSQLite = {} as JsonSQLite;
let tables: JsonTable[] = [];
try {
// get Table's name
let resTables: any[] = await this.getTablesNameSQL(mDB);
if (resTables.length === 0) {
reject(new Error("createExportObject: table's names failed"));
} else {
switch (sqlObj.mode) {
case 'partial': {
tables = await this.getTablesPartial(mDB, resTables);
break;
}
case 'full': {
tables = await this.getTablesFull(mDB, resTables);
break;
}
default: {
reject(
new Error(
'createExportObject: expMode ' + sqlObj.mode + ' not defined',
),
);
break;
}
public async createExportObject(
mDB: any,
sqlObj: JsonSQLite,
): Promise<JsonSQLite> {
const retObj: JsonSQLite = {} as JsonSQLite;
let tables: JsonTable[] = [];
let errmsg = '';
try {
// get Table's name
const resTables: any[] = await this.getTablesNameSQL(mDB);
if (resTables.length === 0) {
return Promise.reject(
new Error("createExportObject: table's names failed"),
);
} else {
switch (sqlObj.mode) {
case 'partial': {
tables = await this.getTablesPartial(mDB, resTables);
break;
}
if (tables.length > 0) {
retObj.database = sqlObj.database;
retObj.version = sqlObj.version;
retObj.encrypted = sqlObj.encrypted;
retObj.mode = sqlObj.mode;
retObj.tables = tables;
case 'full': {
tables = await this.getTablesFull(mDB, resTables);
break;
}
default: {
errmsg =
'createExportObject: expMode ' + sqlObj.mode + ' not defined';
break;
}
}
} catch (err) {
reject(new Error('createExportObject: ' + err.message));
} finally {
resolve(retObj);
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;
}
return Promise.resolve(retObj);
}
});
} catch (err) {
return Promise.reject(new Error('createExportObject: ' + err.message));
}
}

@@ -68,16 +72,13 @@ /**

public async getTablesNameSQL(mDb: any): Promise<any[]> {
return new Promise(async (resolve, reject) => {
let sql: string = '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_%';";
let retQuery: any[] = [];
try {
retQuery = await this._uSQLite.queryAll(mDb, sql, []);
} catch (err) {
reject(new Error(`getTablesNames: ${err.message}`));
} finally {
resolve(retQuery);
}
});
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_%';";
let retQuery: any[] = [];
try {
retQuery = await this._uSQLite.queryAll(mDb, sql, []);
return Promise.resolve(retQuery);
} catch (err) {
return Promise.reject(new Error(`getTablesNames: ${err.message}`));
}
}

@@ -91,5 +92,5 @@

return new Promise((resolve, reject) => {
let retDate: number = -1;
let retDate = -1;
// get the last sync date
let stmt = `SELECT sync_date FROM sync_table;`;
const stmt = `SELECT sync_date FROM sync_table;`;
mDb.get(stmt, [], (err: Error, row: any) => {

@@ -120,68 +121,68 @@ // process the row here

): Promise<JsonTable[]> {
return new Promise(async (resolve, reject) => {
let tables: JsonTable[] = [];
try {
// Loop through the tables
for (let i: number = 0; i < resTables.length; i++) {
let tableName: string;
let sqlStmt: string;
const tables: JsonTable[] = [];
let errmsg = ';';
try {
// Loop through the tables
for (const rTable of resTables) {
let tableName: string;
let sqlStmt: string;
if (resTables[i].name) {
tableName = resTables[i].name;
} else {
reject(new Error('GetTablesFull: no name'));
break;
}
if (resTables[i].sql) {
sqlStmt = resTables[i].sql;
} else {
reject(new Error('GetTablesFull: no sql'));
break;
}
let table: JsonTable = {} as JsonTable;
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: JsonTable = {} as JsonTable;
// create Table's Schema
const schema: JsonColumn[] = await this.getSchema(sqlStmt, tableName);
if (schema.length === 0) {
reject(new Error('GetTablesFull: no Schema returned'));
break;
}
// check schema validity
await this._uJson.checkSchemaValidity(schema);
// create Table's indexes if any
const indexes: JsonIndex[] = await this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
// check indexes validity
await this._uJson.checkIndexesValidity(indexes);
}
// create Table's Data
const query: string = `SELECT * FROM ${tableName};`;
const values: any[] = await this.getValues(mDb, query, tableName);
table.name = tableName;
if (schema.length > 0) {
table.schema = schema;
} else {
reject(new Error(`GetTablesFull: must contain schema`));
break;
}
if (indexes.length > 0) {
table.indexes = indexes;
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
reject(
new Error(`GetTablesFull: table ${tableName} is not a jsonTable`),
);
}
// create Table's Schema
const schema: JsonColumn[] = await this.getSchema(sqlStmt, tableName);
if (schema.length === 0) {
errmsg = 'GetTablesFull: no Schema returned';
break;
}
// check schema validity
await this._uJson.checkSchemaValidity(schema);
// create Table's indexes if any
const indexes: JsonIndex[] = await this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
// check indexes validity
await this._uJson.checkIndexesValidity(indexes);
}
// create Table's Data
const query = `SELECT * FROM ${tableName};`;
const values: any[] = await this.getValues(mDb, 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 (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesFull: table ${tableName} is not a jsonTable`;
break;
}
tables.push(table);
}
} catch (err) {
reject(new Error(`GetTablesFull: ${err.message}`));
} finally {
resolve(tables);
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}`));
}
}

@@ -199,47 +200,49 @@

): Promise<JsonColumn[]> {
return new Promise(async (resolve, reject) => {
let schema: JsonColumn[] = [];
// take the substring between parenthesis
let openPar: number = sqlStmt.indexOf('(');
let closePar: number = sqlStmt.lastIndexOf(')');
let sstr: string = sqlStmt.substring(openPar + 1, closePar);
let isStrfTime: boolean = false;
if (sstr.includes('strftime')) isStrfTime = true;
let sch: Array<string> = sstr.replace(/\n/g, '').split(',');
if (isStrfTime) {
let nSch: string[] = [];
for (let j: number = 0; j < sch.length; j++) {
if (sch[j].includes('strftime')) {
nSch.push(sch[j] + ',' + sch[j + 1]);
j++;
} else {
nSch.push(sch[j]);
}
const schema: JsonColumn[] = [];
// take the substring between parenthesis
const openPar: number = sqlStmt.indexOf('(');
const closePar: number = sqlStmt.lastIndexOf(')');
const sstr: string = sqlStmt.substring(openPar + 1, closePar);
let errmsg = '';
let isStrfTime = false;
if (sstr.includes('strftime')) isStrfTime = true;
let sch: string[] = sstr.replace(/\n/g, '').split(',');
if (isStrfTime) {
const nSch: string[] = [];
for (let j = 0; j < sch.length; j++) {
if (sch[j].includes('strftime')) {
nSch.push(sch[j] + ',' + sch[j + 1]);
j++;
} else {
nSch.push(sch[j]);
}
sch = [...nSch];
}
for (let j: number = 0; j < sch.length; j++) {
const rstr = sch[j].trim();
let idx = rstr.indexOf(' ');
//find the index of the first
let row: Array<string> = [rstr.slice(0, idx), rstr.slice(idx + 1)];
sch = [...nSch];
}
for (const rSch of sch) {
const rstr = rSch.trim();
const idx = rstr.indexOf(' ');
//find the index of the first
let row: string[] = [rstr.slice(0, idx), rstr.slice(idx + 1)];
if (row.length != 2) {
errmsg = `GetSchema: table ${tableName} row length != 2`;
break;
}
if (row[0].toUpperCase() != 'FOREIGN') {
schema.push({ column: row[0], value: row[1] });
} else {
const oPar: number = rstr.indexOf('(');
const cPar: number = rstr.indexOf(')');
row = [rstr.slice(oPar + 1, cPar), rstr.slice(cPar + 2)];
if (row.length != 2) {
reject(new Error(`GetSchema: table ${tableName} row length != 2`));
errmsg = `GetSchema: table ${tableName} row length != 2`;
break;
}
if (row[0].toUpperCase() != 'FOREIGN') {
schema.push({ column: row[0], value: row[1] });
} else {
const oPar: number = rstr.indexOf('(');
const cPar: number = rstr.indexOf(')');
row = [rstr.slice(oPar + 1, cPar), rstr.slice(cPar + 2)];
if (row.length != 2) {
reject(new Error(`GetSchema: table ${tableName} row length != 2`));
break;
}
schema.push({ foreignkey: row[0], value: row[1] });
}
schema.push({ foreignkey: row[0], value: row[1] });
}
resolve(schema);
});
}
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
return Promise.resolve(schema);
}

@@ -254,43 +257,40 @@

private async getIndexes(mDb: any, tableName: string): Promise<JsonIndex[]> {
return new Promise(async (resolve, reject) => {
let indexes: JsonIndex[] = [];
try {
let stmt: string = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
stmt += `type = 'index' AND tbl_name = '${tableName}' `;
stmt += `AND sql NOTNULL;`;
const retIndexes = await this._uSQLite.queryAll(mDb, stmt, []);
if (retIndexes.length > 0) {
for (let j: number = 0; j < retIndexes.length; j++) {
const keys: Array<string> = Object.keys(retIndexes[j]);
if (keys.length === 3) {
if (retIndexes[j]['tbl_name'] === tableName) {
const sql: string = retIndexes[j]['sql'];
const mode: string = sql.includes('UNIQUE') ? 'UNIQUE' : '';
const oPar: number = sql.lastIndexOf('(');
const cPar: number = sql.lastIndexOf(')');
let index: JsonIndex = {} as JsonIndex;
index.name = retIndexes[j]['name'];
index.value = sql.slice(oPar + 1, cPar);
if (mode.length > 0) index.mode = mode;
indexes.push(index);
} else {
reject(
new Error(`GetIndexes: Table ${tableName} doesn't match`),
);
break;
}
const indexes: JsonIndex[] = [];
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 this._uSQLite.queryAll(mDb, stmt, []);
if (retIndexes.length > 0) {
for (const rIndex of retIndexes) {
const keys: string[] = Object.keys(rIndex);
if (keys.length === 3) {
if (rIndex['tbl_name'] === tableName) {
const sql: string = rIndex['sql'];
const mode: string = sql.includes('UNIQUE') ? 'UNIQUE' : '';
const oPar: number = sql.lastIndexOf('(');
const cPar: number = sql.lastIndexOf(')');
const index: JsonIndex = {} as JsonIndex;
index.name = rIndex['name'];
index.value = sql.slice(oPar + 1, cPar);
if (mode.length > 0) index.mode = mode;
indexes.push(index);
} else {
reject(
new Error(`GetIndexes: Table ${tableName} creating indexes`),
);
errmsg = `GetIndexes: Table ${tableName} doesn't match`;
break;
}
} else {
errmsg = `GetIndexes: Table ${tableName} creating indexes`;
break;
}
}
} catch (err) {
reject(new Error(`GetIndexes: ${err.message}`));
} finally {
resolve(indexes);
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
}
});
return Promise.resolve(indexes);
} catch (err) {
return Promise.reject(new Error(`GetIndexes: ${err.message}`));
}
}

@@ -308,35 +308,33 @@ /**

): Promise<any[]> {
return new Promise(async (resolve, reject) => {
let values: any[] = [];
try {
// get table column names and types
const tableNamesTypes = await this._uJson.getTableColumnNamesTypes(
mDb,
tableName,
const values: any[] = [];
try {
// get table column names and types
const tableNamesTypes = await this._uJson.getTableColumnNamesTypes(
mDb,
tableName,
);
let rowNames: string[] = [];
if (Object.keys(tableNamesTypes).includes('names')) {
rowNames = tableNamesTypes.names;
} else {
return Promise.reject(
new Error(`GetValues: Table ${tableName} no names`),
);
let rowNames: string[] = [];
if (Object.keys(tableNamesTypes).includes('names')) {
rowNames = tableNamesTypes.names;
} else {
reject(new Error(`GetValues: Table ${tableName} no names`));
}
const retValues = await this._uSQLite.queryAll(mDb, query, []);
for (let j: number = 0; j < retValues.length; j++) {
let row: any[] = [];
for (let k: number = 0; k < rowNames.length; k++) {
const nName: string = rowNames[k];
if (Object.keys(retValues[j]).includes(nName)) {
row.push(retValues[j][nName]);
} else {
row.push('NULL');
}
}
const retValues = await this._uSQLite.queryAll(mDb, query, []);
for (const rValue of retValues) {
const row: any[] = [];
for (const rName of rowNames) {
if (Object.keys(rValue).includes(rName)) {
row.push(rValue[rName]);
} else {
row.push('NULL');
}
values.push(row);
}
} catch (err) {
reject(new Error(`GetValues: ${err.message}`));
} finally {
resolve(values);
values.push(row);
}
});
return Promise.resolve(values);
} catch (err) {
return Promise.reject(new Error(`GetValues: ${err.message}`));
}
}

@@ -353,98 +351,96 @@

): Promise<JsonTable[]> {
return new Promise(async (resolve, reject) => {
let tables: JsonTable[] = [];
let modTables: any = {};
let syncDate: number = 0;
let modTablesKeys: string[] = [];
try {
// Get the syncDate and the Modified Tables
const partialModeData: any = await this.getPartialModeData(
mDb,
resTables,
);
if (Object.keys(partialModeData).includes('syncDate')) {
syncDate = partialModeData.syncDate;
const tables: JsonTable[] = [];
let modTables: any = {};
let syncDate = 0;
let modTablesKeys: string[] = [];
let errmsg = '';
try {
// Get the syncDate and the Modified Tables
const partialModeData: any = await this.getPartialModeData(
mDb,
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 (Object.keys(partialModeData).includes('modTables')) {
modTables = partialModeData.modTables;
modTablesKeys = Object.keys(modTables);
if (rTable.sql) {
sqlStmt = rTable.sql;
} else {
errmsg = 'GetTablesFull: no sql';
break;
}
// Loop trough tables
for (let i: number = 0; i < resTables.length; i++) {
let tableName: string = '';
let sqlStmt: string = '';
if (resTables[i].name) {
tableName = resTables[i].name;
} else {
reject(new Error('GetTablesFull: no name'));
break;
}
if (resTables[i].sql) {
sqlStmt = resTables[i].sql;
} else {
reject(new Error('GetTablesFull: no sql'));
break;
}
if (
modTablesKeys.length == 0 ||
modTablesKeys.indexOf(tableName) === -1 ||
modTables[tableName] == 'No'
) {
continue;
}
let table: JsonTable = {} as JsonTable;
let schema: JsonColumn[] = [];
let indexes: JsonIndex[] = [];
table.name = resTables[i];
if (modTables[table.name] === 'Create') {
// create Table's Schema
schema = await this.getSchema(sqlStmt, tableName);
if (schema.length > 0) {
// check schema validity
await this._uJson.checkSchemaValidity(schema);
}
// create Table's indexes if any
indexes = await this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
// check indexes validity
await this._uJson.checkIndexesValidity(indexes);
}
}
// create Table's Data
let query: string = '';
if (modTables[tableName] === 'Create') {
query = `SELECT * FROM ${tableName};`;
} else {
query =
`SELECT * FROM ${tableName} ` +
`WHERE last_modified > ${syncDate};`;
}
const values: any[] = await this.getValues(mDb, query, tableName);
// check the table object validity
table.name = tableName;
if (
modTablesKeys.length == 0 ||
modTablesKeys.indexOf(tableName) === -1 ||
modTables[tableName] == 'No'
) {
continue;
}
const table: JsonTable = {} as JsonTable;
let schema: JsonColumn[] = [];
let indexes: JsonIndex[] = [];
table.name = rTable;
if (modTables[table.name] === 'Create') {
// create Table's Schema
schema = await this.getSchema(sqlStmt, tableName);
if (schema.length > 0) {
table.schema = schema;
// check schema validity
await this._uJson.checkSchemaValidity(schema);
}
// create Table's indexes if any
indexes = await this.getIndexes(mDb, tableName);
if (indexes.length > 0) {
table.indexes = indexes;
// check indexes validity
await this._uJson.checkIndexesValidity(indexes);
}
if (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
reject(
new Error(
`GetTablesPartial: table ${tableName} is not a jsonTable`,
),
);
}
tables.push(table);
}
} catch (err) {
reject(new Error(`GetTablesPartial: ${err.message}`));
} finally {
resolve(tables);
// 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: any[] = await this.getValues(mDb, 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 (values.length > 0) {
table.values = values;
}
if (Object.keys(table).length <= 1) {
errmsg = `GetTablesPartial: table ${tableName} is not a jsonTable`;
break;
}
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}`));
}
}

@@ -457,28 +453,25 @@ /**

private async getPartialModeData(mDb: any, resTables: any[]): Promise<any> {
return new Promise(async (resolve, reject) => {
let retData: any = {};
try {
// get the synchronization date
const syncDate: number = await this.getSyncDate(mDb);
if (syncDate <= 0) {
reject(new Error(`GetPartialModeData: no syncDate`));
}
// get the tables which have been updated
// since last synchronization
const modTables: any = await this.getTablesModified(
mDb,
resTables,
syncDate,
);
if (modTables.length <= 0) {
reject(new Error(`GetPartialModeData: no modTables`));
}
retData.syncDate = syncDate;
retData.modTables = modTables;
} catch (err) {
reject(new Error(`GetPartialModeData: ${err.message}`));
} finally {
resolve(retData);
const retData: any = {};
try {
// get the synchronization date
const syncDate: number = await this.getSyncDate(mDb);
if (syncDate <= 0) {
return Promise.reject(new Error(`GetPartialModeData: no syncDate`));
}
});
// get the tables which have been updated
// since last synchronization
const modTables: any = await this.getTablesModified(
mDb,
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}`));
}
}

@@ -490,156 +483,42 @@ private async getTablesModified(

): Promise<any> {
return new Promise(async (resolve, reject) => {
try {
let retModified: any = {};
for (let i: number = 0; i < tables.length; i++) {
let mode: string;
// get total count of the table
let stmt: string = 'SELECT count(*) AS tcount ';
stmt += `FROM ${tables[i].name};`;
let retQuery: Array<any> = await this._uSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) {
reject(
new Error('GetTableModified: total ' + 'count not returned'),
);
}
const totalCount: number = retQuery[0]['tcount'];
// get total count of modified since last sync
stmt = 'SELECT count(*) AS mcount FROM ';
stmt += `${tables[i].name} WHERE last_modified > `;
stmt += `${syncDate};`;
retQuery = await this._uSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) break;
const totalModifiedCount: number = retQuery[0]['mcount'];
if (totalModifiedCount === 0) {
mode = 'No';
} else if (totalCount === totalModifiedCount) {
mode = 'Create';
} else {
mode = 'Modified';
}
const key: string = tables[i].name;
retModified[key] = mode;
if (i === tables.length - 1) resolve(retModified);
let errmsg = '';
try {
const retModified: any = {};
for (const rTable of tables) {
let mode: string;
// get total count of the table
let stmt = 'SELECT count(*) AS tcount ';
stmt += `FROM ${rTable.name};`;
let retQuery: any[] = await this._uSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) {
errmsg = 'GetTableModified: total ' + 'count not returned';
break;
}
} catch (err) {
reject(new Error(`GetTableModified: ${err.message}`));
}
});
}
/*
private async createJsonTable(
mDB: any,
nTable: any,
mode: string,
modTables: any,
): Promise<JsonTable> {
return new Promise(async (resolve, reject) => {
let table: JsonTable = {} as JsonTable;
// let isSchema: boolean = false;
// let isIndexes: boolean = false;
// let isTriggers: boolean = false;
// let isValues: boolean = false;
table.name = nTable.name;
try {
if (
mode === 'full' ||
(mode === 'partial' && modTables[table.name] === 'Create')
) {
// create JsonSchema
const schema: JsonColumn[] = await this.createJsonTableSchema(nTable);
table.schema = schema;
// isSchema = true;
// create JsonIndexes
const indexes: JsonIndex[] = await this.createJsonTableIndexes(
mDB,
nTable,
);
table.indexes = indexes;
// isIndexes = true;
// create Triggers
}
const totalCount: number = 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 this._uSQLite.queryAll(db, stmt, []);
if (retQuery.length != 1) break;
const totalModifiedCount: number = retQuery[0]['mcount'];
resolve(table);
} catch (err) {
reject(new Error(`CreateJsonTable: ${err.message}`));
}
});
}
private async createJsonTableSchema(table: any): Promise<JsonColumn[]> {
return new Promise(async (resolve, reject) => {
try {
let schema: Array<JsonColumn> = [];
// take the substring between parenthesis
let openPar: number = table.sql.indexOf('(');
let closePar: number = table.sql.lastIndexOf(')');
let sstr: String = table.sql.substring(openPar + 1, closePar);
let isStrfTime: boolean = false;
if (sstr.includes('strftime')) isStrfTime = true;
let sch: Array<string> = sstr.replace(/\n/g, '').split(',');
if (isStrfTime) {
let nSch: string[] = [];
for (let j: number = 0; j < sch.length; j++) {
if (sch[j].includes('strftime')) {
nSch.push(sch[j] + ',' + sch[j + 1]);
j++;
} else {
nSch.push(sch[j]);
}
}
sch = [...nSch];
if (totalModifiedCount === 0) {
mode = 'No';
} else if (totalCount === totalModifiedCount) {
mode = 'Create';
} else {
mode = 'Modified';
}
for (let j: number = 0; j < sch.length; j++) {
const rstr = sch[j].trim();
let idx = rstr.indexOf(' ');
//find the index of the first
let row: Array<string> = [rstr.slice(0, idx), rstr.slice(idx + 1)];
if (row.length != 2) {
reject(
new Error(
'CreateJsonTableSchema: ' + 'failed in returning sql statement',
),
);
}
if (row[0].toUpperCase() != 'FOREIGN') {
schema.push({ column: row[0], value: row[1] });
} else {
const oPar: number = rstr.indexOf('(');
const cPar: number = rstr.indexOf(')');
row = [rstr.slice(oPar + 1, cPar), rstr.slice(cPar + 2)];
if (row.length != 2) {
reject(
new Error(
'CreateJsonTableSchema: ' +
'failed in returning sql FOREIGN statement',
),
);
}
schema.push({ foreignkey: row[0], value: row[1] });
}
}
console.log('schema ' + JSON.stringify(schema));
resolve(schema);
} catch (err) {
reject(new Error(`CreateJsonTableSchema: ${err.message}`));
const key: string = rTable.name;
retModified[key] = mode;
}
});
}
private async createJsonTableIndexes(
mDB: any,
table: any,
): Promise<JsonIndex[]> {
return new Promise(async (resolve, reject) => {
try {
let indexes: JsonIndex[] = [];
console.log('mDB ' + JSON.stringify(mDB));
console.log('table ' + JSON.stringify(table));
resolve(indexes);
} catch (err) {
reject(new Error(`CreateJsonTableIndexes: ${err.message}`));
if (errmsg.length > 0) {
return Promise.reject(new Error(errmsg));
}
});
return Promise.resolve(retModified);
} catch (err) {
return Promise.reject(new Error(`GetTableModified: ${err.message}`));
}
}
*/
}

146

electron/src/electron-utils/ImportExportJson/importFromJson.ts

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

import { JsonSQLite } from '../../definitions';
import { UtilsJson } from './utilsJson';
import type { JsonSQLite } from '../../definitions';
import { UtilsDrop } from '../utilsDrop';
import { UtilsSQLite } from '../utilsSQLite';
import { UtilsDrop } from '../utilsDrop';
import { UtilsJson } from './utilsJson';
export class ImportFromJson {

@@ -15,76 +16,81 @@ private _uJson: UtilsJson = new UtilsJson();

*/
public createDatabaseSchema(mDB: any, jsonData: JsonSQLite): Promise<number> {
return new Promise(async (resolve, reject) => {
let changes: number = -1;
const version: number = jsonData.version;
public async createDatabaseSchema(
mDB: any,
jsonData: JsonSQLite,
): Promise<number> {
let changes = -1;
const version: number = jsonData.version;
try {
// set Foreign Keys On
await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
// set User Version PRAGMA
await this._uSQLite.setVersion(mDB, version);
// DROP ALL when mode="full"
if (jsonData.mode === 'full') {
await this._uDrop.dropAll(mDB);
}
// create database schema
changes = await this._uJson.createSchema(mDB, jsonData);
return Promise.resolve(changes);
} catch (err) {
return Promise.reject(
new Error('CreateDatabaseSchema: ' + `${err.message}`),
);
}
}
public async createTablesData(
mDB: any,
jsonData: JsonSQLite,
): Promise<number> {
let changes = 0;
let isValue = false;
let lastId = -1;
let msg = '';
let initChanges = -1;
try {
initChanges = await this._uSQLite.dbChanges(mDB);
// start a transaction
await this._uSQLite.beginTransaction(mDB, 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
try {
lastId = await this._uJson.createDataTable(
mDB,
jTable,
jsonData.mode,
);
if (lastId < 0) break;
isValue = true;
} catch (err) {
msg = err.message;
isValue = false;
break;
}
}
}
if (isValue) {
try {
// set Foreign Keys On
await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
// set User Version PRAGMA
await this._uSQLite.setVersion(mDB, version);
// DROP ALL when mode="full"
if (jsonData.mode === 'full') {
await this._uDrop.dropAll(mDB);
}
// create database schema
changes = await this._uJson.createSchema(mDB, jsonData);
resolve(changes);
await this._uSQLite.commitTransaction(mDB, true);
changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
return Promise.resolve(changes);
} catch (err) {
reject(new Error('CreateDatabaseSchema: ' + `${err.message}`));
return Promise.reject(
new Error('createTablesData: ' + `${err.message}`),
);
}
});
}
public createTablesData(mDB: any, jsonData: JsonSQLite): Promise<number> {
return new Promise(async (resolve, reject) => {
let changes: number = 0;
let isValue: boolean = false;
let lastId: number = -1;
let msg: string = '';
let initChanges: number = -1;
} else {
try {
initChanges = await this._uSQLite.dbChanges(mDB);
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
await this._uSQLite.rollbackTransaction(mDB, true);
return Promise.reject(new Error(`createTablesData: ${msg}`));
} catch (err) {
reject(new Error(`createTablesData: ${err.message}`));
return Promise.reject(
new Error('createTablesData: ' + `${err.message}: ${msg}`),
);
}
for (let i: number = 0; i < jsonData.tables.length; i++) {
if (
jsonData.tables[i].values != null &&
jsonData.tables[i].values!.length >= 1
) {
// Create the table's data
try {
lastId = await this._uJson.createDataTable(
mDB,
jsonData.tables[i],
jsonData.mode,
);
if (lastId < 0) break;
isValue = true;
} catch (err) {
msg = err.message;
isValue = false;
break;
}
}
}
if (isValue) {
try {
await this._uSQLite.commitTransaction(mDB, true);
changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
resolve(changes);
} catch (err) {
reject(new Error('createTablesData: ' + `${err.message}`));
}
} else {
try {
await this._uSQLite.rollbackTransaction(mDB, true);
reject(new Error(`createTablesData: ${msg}`));
} catch (err) {
reject(new Error('createTablesData: ' + `${err.message}: ${msg}`));
}
}
});
}
}
}

554

electron/src/electron-utils/ImportExportJson/utilsJson.ts

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

import type { JsonColumn, JsonIndex } from '../../definitions';
import { UtilsSQLite } from '../utilsSQLite';
import { JsonColumn, JsonIndex } from '../../definitions';

@@ -21,3 +21,3 @@ export class UtilsJson {

}
let query: string = 'SELECT name FROM sqlite_master WHERE ';
let query = 'SELECT name FROM sqlite_master WHERE ';
query += `type='table' AND name='${tableName}';`;

@@ -44,47 +44,45 @@ db.all(query, [], (err: Error, rows: any[]) => {

public async createSchema(mDB: any, jsonData: any): Promise<number> {
return new Promise(async (resolve, reject) => {
// create the database schema
let changes: number = 0;
// create the database schema
let changes = 0;
try {
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
} catch (err) {
return Promise.reject(new Error(`CreateDatabaseSchema: ${err.message}`));
}
const stmts = await this.createSchemaStatement(jsonData);
if (stmts.length > 0) {
const schemaStmt: string = stmts.join('\n');
try {
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
} catch (err) {
reject(new Error(`CreateDatabaseSchema: ${err.message}`));
}
const stmts = await this.createSchemaStatement(jsonData);
if (stmts.length > 0) {
const schemaStmt: string = stmts.join('\n');
try {
changes = await this._uSQLite.execute(mDB, schemaStmt);
if (changes < 0) {
try {
await this._uSQLite.rollbackTransaction(mDB, true);
} catch (err) {
reject(
new Error('CreateSchema: changes < 0 ' + `${err.message}`),
);
}
}
} catch (err) {
const msg = err.message;
changes = await this._uSQLite.execute(mDB, schemaStmt);
if (changes < 0) {
try {
await this._uSQLite.rollbackTransaction(mDB, true);
reject(new Error(`CreateSchema: ${msg}`));
} catch (err) {
reject(
new Error(
'CreateSchema: changes < 0 ' + `${err.message}: ${msg}`,
),
return Promise.reject(
new Error('CreateSchema: changes < 0 ' + `${err.message}`),
);
}
}
}
try {
await this._uSQLite.commitTransaction(mDB, true);
resolve(changes);
} catch (err) {
reject(new Error('CreateSchema: commit ' + `${err.message}`));
const msg = err.message;
try {
await this._uSQLite.rollbackTransaction(mDB, true);
return Promise.reject(new Error(`CreateSchema: ${msg}`));
} catch (err) {
return Promise.reject(
new Error('CreateSchema: changes < 0 ' + `${err.message}: ${msg}`),
);
}
}
});
}
try {
await this._uSQLite.commitTransaction(mDB, true);
return Promise.resolve(changes);
} catch (err) {
return Promise.reject(
new Error('CreateSchema: commit ' + `${err.message}`),
);
}
}

@@ -97,41 +95,28 @@

public async createSchemaStatement(jsonData: any): Promise<string[]> {
return new Promise(resolve => {
let statements: string[] = [];
// Prepare the statement to execute
for (let i: number = 0; i < jsonData.tables.length; i++) {
if (
jsonData.tables[i].schema != null &&
jsonData.tables[i].schema!.length >= 1
) {
const statements: string[] = [];
// 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 ' + `${jsonData.tables[i].name} (`,
);
for (let j: number = 0; j < jsonData.tables[i].schema!.length; j++) {
if (j === jsonData.tables[i].schema!.length - 1) {
if (jsonData.tables[i].schema![j].column) {
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.column) {
statements.push(
`${jsonData.tables[i].schema![j].column} ${
jsonData.tables[i].schema![j].value
}`,
`${jTable.schema.column} ${jTable.schema[j].value}`,
);
} else if (jsonData.tables[i].schema![j].foreignkey) {
} else if (jTable.schema[j].foreignkey) {
statements.push(
`FOREIGN KEY (${jsonData.tables[i].schema![j].foreignkey}) ${
jsonData.tables[i].schema![j].value
}`,
`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value}`,
);
}
} else {
if (jsonData.tables[i].schema![j].column) {
if (jTable.schema[j].column) {
statements.push(
`${jsonData.tables[i].schema![j].column} ${
jsonData.tables[i].schema![j].value
},`,
`${jTable.schema[j].column} ${jTable.schema[j].value},`,
);
} else if (jsonData.tables[i].schema![j].foreignkey) {
} else if (jTable.schema[j].foreignkey) {
statements.push(
`FOREIGN KEY (${jsonData.tables[i].schema![j].foreignkey}) ${
jsonData.tables[i].schema![j].value
},`,
`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value},`,
);

@@ -143,9 +128,9 @@ }

// create trigger last_modified associated with the table
let trig: string = 'CREATE TRIGGER IF NOT EXISTS ';
trig += `${jsonData.tables[i].name}`;
let trig = 'CREATE TRIGGER IF NOT EXISTS ';
trig += `${jTable.name}`;
trig += `_trigger_last_modified `;
trig += `AFTER UPDATE ON ${jsonData.tables[i].name} `;
trig += `AFTER UPDATE ON ${jTable.name} `;
trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
trig += 'OLD.last_modified BEGIN UPDATE ';
trig += `${jsonData.tables[i].name} `;
trig += `${jTable.name} `;
trig += `SET last_modified = `;

@@ -155,13 +140,9 @@ trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";

}
if (
jsonData.tables[i].indexes != null &&
jsonData.tables[i].indexes!.length >= 1
) {
for (let j: number = 0; j < jsonData.tables[i].indexes!.length; j++) {
const index = jsonData.tables[i].indexes![j];
const tableName = jsonData.tables[i].name;
let stmt: string = `CREATE ${
Object.keys(index).includes('mode') ? index.mode + ' ' : ''
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 `;
stmt += `${index.name} ON ${tableName} (${index.value});`;
stmt += `${jIndex.name} ON ${tableName} (${jIndex.value});`;
statements.push(stmt);

@@ -171,4 +152,6 @@ }

}
resolve(statements);
});
return Promise.resolve(statements);
} catch (err) {
return Promise.reject(err);
}
}

@@ -187,95 +170,91 @@

): Promise<number> {
return new Promise(async (resolve, reject) => {
let lastId: number = -1;
try {
// Check if the table exists
const tableExists = await this.isTableExists(mDB, true, table.name);
if (!tableExists) {
reject(
let lastId = -1;
try {
// Check if the table exists
const tableExists = await this.isTableExists(mDB, true, table.name);
if (!tableExists) {
return Promise.reject(
new Error('CreateDataTable: Table ' + `${table.name} does not exist`),
);
}
// Get the column names and types
const tableNamesTypes: any = await this.getTableColumnNamesTypes(
mDB,
table.name,
);
const tableColumnTypes: string[] = tableNamesTypes.types;
const tableColumnNames: string[] = tableNamesTypes.names;
if (tableColumnTypes.length === 0) {
return Promise.reject(
new Error(
'CreateDataTable: Table ' + `${table.name} info does not exist`,
),
);
}
// Loop on Table Values
for (let j = 0; j < table.values.length; j++) {
// Check the row number of columns
if (table.values[j].length != tableColumnTypes.length) {
return Promise.reject(
new Error(
'CreateDataTable: Table ' + `${table.name} does not exist`,
`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct length`,
),
);
}
// Get the column names and types
const tableNamesTypes: any = await this.getTableColumnNamesTypes(
mDB,
table.name,
// Check the column's type before proceeding
const isColumnTypes: boolean = await this.checkColumnTypes(
tableColumnTypes,
table.values[j],
);
const tableColumnTypes: Array<string> = tableNamesTypes.types;
const tableColumnNames: Array<string> = tableNamesTypes.names;
if (tableColumnTypes.length === 0) {
reject(
if (!isColumnTypes) {
return Promise.reject(
new Error(
'CreateDataTable: Table ' + `${table.name} info does not exist`,
`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct types`,
),
);
}
// Loop on Table Values
for (let j: number = 0; j < table.values!.length; j++) {
// Check the row number of columns
if (table.values![j].length != tableColumnTypes.length) {
reject(
new Error(
`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct length`,
),
);
}
// Check the column's type before proceeding
const isColumnTypes: boolean = await this.checkColumnTypes(
tableColumnTypes,
table.values![j],
const retisIdExists: boolean = await this.isIdExists(
mDB,
table.name,
tableColumnNames[0],
table.values[j][0],
);
let stmt: string;
if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
// Insert
const nameString: string = tableColumnNames.join();
const questionMarkString = await this.createQuestionMarkString(
tableColumnNames.length,
);
if (!isColumnTypes) {
reject(
stmt = `INSERT INTO ${table.name} (${nameString}) VALUES (`;
stmt += `${questionMarkString});`;
} else {
// Update
const setString: string = await this.setNameForUpdate(
tableColumnNames,
);
if (setString.length === 0) {
return Promise.reject(
new Error(
`CreateDataTable: Table ${table.name} ` +
`values row ${j} not correct types`,
`values row ${j} not set to String`,
),
);
}
const retisIdExists: boolean = await this.isIdExists(
mDB,
table.name,
tableColumnNames[0],
table.values![j][0],
);
let stmt: string;
if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
// Insert
const nameString: string = tableColumnNames.join();
const questionMarkString = await this.createQuestionMarkString(
tableColumnNames.length,
);
stmt = `INSERT INTO ${table.name} (${nameString}) VALUES (`;
stmt += `${questionMarkString});`;
} else {
// Update
const setString: string = await this.setNameForUpdate(
tableColumnNames,
);
if (setString.length === 0) {
reject(
new Error(
`CreateDataTable: Table ${table.name} ` +
`values row ${j} not set to String`,
),
);
}
stmt =
`UPDATE ${table.name} SET ${setString} WHERE ` +
`${tableColumnNames[0]} = ${table.values![j][0]};`;
}
lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values![j]);
if (lastId < 0) {
reject(new Error('CreateDataTable: lastId < 0'));
}
stmt =
`UPDATE ${table.name} SET ${setString} WHERE ` +
`${tableColumnNames[0]} = ${table.values[j][0]};`;
}
resolve(lastId);
} catch (err) {
reject(new Error(`CreateDataTable: ${err.message}`));
lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
if (lastId < 0) {
return Promise.reject(new Error('CreateDataTable: lastId < 0'));
}
}
});
return Promise.resolve(lastId);
} catch (err) {
return Promise.reject(new Error(`CreateDataTable: ${err.message}`));
}
}

@@ -288,21 +267,24 @@

*/
public getTableColumnNamesTypes(mDB: any, tableName: string): Promise<any> {
return new Promise(async (resolve, reject) => {
let resQuery: any[] = [];
let retNames: string[] = [];
let retTypes: Array<string> = [];
const query: string = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await this._uSQLite.queryAll(mDB, query, []);
if (resQuery.length > 0) {
for (let i: number = 0; i < resQuery.length; i++) {
retNames.push(resQuery[i].name);
retTypes.push(resQuery[i].type);
}
public async getTableColumnNamesTypes(
mDB: any,
tableName: string,
): Promise<any> {
let resQuery: any[] = [];
const retNames: string[] = [];
const retTypes: string[] = [];
const query = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await this._uSQLite.queryAll(mDB, query, []);
if (resQuery.length > 0) {
for (const query of resQuery) {
retNames.push(query.name);
retTypes.push(query.type);
}
resolve({ names: retNames, types: retTypes });
} catch (err) {
reject(new Error('GetTableColumnNamesTypes: ' + `${err.message}`));
}
});
return Promise.resolve({ names: retNames, types: retTypes });
} catch (err) {
return Promise.reject(
new Error('GetTableColumnNamesTypes: ' + `${err.message}`),
);
}
}

@@ -315,19 +297,17 @@

*/
private checkColumnTypes(
tableTypes: Array<any>,
rowValues: Array<any>,
private async checkColumnTypes(
tableTypes: any[],
rowValues: any[],
): Promise<boolean> {
return new Promise(async (resolve, reject) => {
let isType: boolean = true;
for (let i: number = 0; i < rowValues.length; i++) {
if (rowValues[i].toString().toUpperCase() != 'NULL') {
try {
await this.isType(tableTypes[i], rowValues[i]);
} catch (err) {
reject(new Error('checkColumnTypes: Type not found'));
}
const isType = true;
for (let i = 0; i < rowValues.length; i++) {
if (rowValues[i].toString().toUpperCase() != 'NULL') {
try {
await this.isType(tableTypes[i], rowValues[i]);
} catch (err) {
return Promise.reject(new Error('checkColumnTypes: Type not found'));
}
}
resolve(isType);
});
}
return Promise.resolve(isType);
}

@@ -340,16 +320,14 @@

*/
private isType(type: string, value: any): Promise<void> {
return new Promise((resolve, reject) => {
let ret: boolean = 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) {
resolve();
} else {
reject(new Error('IsType: not a SQL Type'));
}
});
private async isType(type: string, value: any): Promise<void> {
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'));
}
}

@@ -364,3 +342,3 @@

*/
private isIdExists(
private async isIdExists(
db: any,

@@ -371,15 +349,13 @@ dbName: string,

): Promise<boolean> {
return new Promise(async (resolve, reject) => {
let ret: boolean = false;
const query: string =
`SELECT ${firstColumnName} FROM ` +
`${dbName} WHERE ${firstColumnName} = ${key};`;
try {
} catch (err) {
reject(new Error(`IsIdExists: ${err.message}`));
}
const resQuery: Array<any> = await this._uSQLite.queryAll(db, query, []);
let ret = false;
const query: string =
`SELECT ${firstColumnName} FROM ` +
`${dbName} WHERE ${firstColumnName} = ${key};`;
try {
const resQuery: any[] = await this._uSQLite.queryAll(db, query, []);
if (resQuery.length === 1) ret = true;
resolve(ret);
});
return Promise.resolve(ret);
} catch (err) {
return Promise.reject(new Error(`IsIdExists: ${err.message}`));
}
}

@@ -393,4 +369,4 @@

return new Promise((resolve, reject) => {
var retString: string = '';
for (let i: number = 0; i < length; i++) {
let retString = '';
for (let i = 0; i < length; i++) {
retString += '?,';

@@ -411,15 +387,13 @@ }

*/
private setNameForUpdate(names: String[]): Promise<string> {
return new Promise((resolve, reject) => {
var retString: string = '';
for (let i: number = 0; i < names.length; i++) {
retString += `${names[i]} = ? ,`;
}
if (retString.length > 1) {
retString = retString.slice(0, -1);
resolve(retString);
} else {
reject(new Error('SetNameForUpdate: length = 0'));
}
});
private async setNameForUpdate(names: string[]): Promise<string> {
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'));
}
}

@@ -432,3 +406,3 @@

public isJsonSQLite(obj: any): boolean {
const keyFirstLevel: Array<string> = [
const keyFirstLevel: string[] = [
'database',

@@ -445,3 +419,3 @@ 'version',

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keyFirstLevel.indexOf(key) === -1) return false;

@@ -454,4 +428,4 @@ if (key === 'database' && typeof obj[key] != 'string') return false;

if (key === 'tables') {
for (let i: number = 0; i < obj[key].length; i++) {
const retTable: boolean = this.isTable(obj[key][i]);
for (const oKey of obj[key]) {
const retTable: boolean = this.isTable(oKey);
if (!retTable) return false;

@@ -469,9 +443,4 @@ }

private isTable(obj: any): boolean {
const keyTableLevel: Array<string> = [
'name',
'schema',
'indexes',
'values',
];
let nbColumn: number = 0;
const keyTableLevel: string[] = ['name', 'schema', 'indexes', 'values'];
let nbColumn = 0;
if (

@@ -482,3 +451,3 @@ obj == null ||

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keyTableLevel.indexOf(key) === -1) return false;

@@ -501,3 +470,3 @@ if (key === 'name' && typeof obj[key] != 'string') return false;

);
for (let i: number = 0; i < nbColumn; i++) {
for (let i = 0; i < nbColumn; i++) {
const retSchema: boolean = this.isSchema(obj[key][i]);

@@ -508,4 +477,4 @@ if (!retSchema) return false;

if (key === 'indexes') {
for (let i: number = 0; i < obj[key].length; i++) {
const retIndexes: boolean = this.isIndexes(obj[key][i]);
for (const oKey of obj[key]) {
const retIndexes: boolean = this.isIndexes(oKey);
if (!retIndexes) return false;

@@ -516,7 +485,4 @@ }

if (nbColumn > 0) {
for (let i: number = 0; i < obj[key].length; i++) {
if (
typeof obj[key][i] != 'object' ||
obj[key][i].length != nbColumn
)
for (const oKey of obj[key]) {
if (typeof oKey != 'object' || oKey.length != nbColumn)
return false;

@@ -535,3 +501,3 @@ }

private isSchema(obj: any): boolean {
const keySchemaLevel: Array<string> = ['column', 'value', 'foreignkey'];
const keySchemaLevel: string[] = ['column', 'value', 'foreignkey'];
if (

@@ -542,3 +508,3 @@ obj == null ||

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keySchemaLevel.indexOf(key) === -1) return false;

@@ -556,3 +522,3 @@ if (key === 'column' && typeof obj[key] != 'string') return false;

private isIndexes(obj: any): boolean {
const keyIndexesLevel: Array<string> = ['name', 'value', 'mode'];
const keyIndexesLevel: string[] = ['name', 'value', 'mode'];
if (

@@ -563,3 +529,3 @@ obj == null ||

return false;
for (var key of Object.keys(obj)) {
for (const key of Object.keys(obj)) {
if (keyIndexesLevel.indexOf(key) === -1) return false;

@@ -582,22 +548,22 @@ if (key === 'name' && typeof obj[key] != 'string') return false;

public async checkSchemaValidity(schema: JsonColumn[]): Promise<void> {
return new Promise(async (resolve, reject) => {
for (let i: number = 0; i < schema.length; i++) {
let sch: JsonColumn = {} as JsonColumn;
let keys: string[] = 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;
}
let isValid: boolean = this.isSchema(sch);
if (!isValid) {
reject(new Error(`CheckSchemaValidity: schema[${i}] not valid`));
}
for (let i = 0; i < schema.length; i++) {
const sch: JsonColumn = {} as JsonColumn;
const keys: string[] = Object.keys(schema[i]);
if (keys.includes('column')) {
sch.column = schema[i].column;
}
resolve();
});
if (keys.includes('value')) {
sch.value = schema[i].value;
}
if (keys.includes('foreignkey')) {
sch.foreignkey = schema[i].foreignkey;
}
const isValid: boolean = this.isSchema(sch);
if (!isValid) {
return Promise.reject(
new Error(`CheckSchemaValidity: schema[${i}] not valid`),
);
}
}
return Promise.resolve();
}

@@ -609,24 +575,24 @@ /**

public async checkIndexesValidity(indexes: JsonIndex[]): Promise<void> {
return new Promise(async (resolve, reject) => {
for (let i: number = 0; i < indexes.length; i++) {
let index: JsonIndex = {} as JsonIndex;
let keys: string[] = 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;
}
for (let i = 0; i < indexes.length; i++) {
const index: JsonIndex = {} as JsonIndex;
const keys: string[] = 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;
}
let isValid: boolean = this.isIndexes(index);
if (!isValid) {
reject(new Error(`CheckIndexesValidity: indexes[${i}] not valid`));
}
const isValid: boolean = this.isIndexes(index);
if (!isValid) {
return Promise.reject(
new Error(`CheckIndexesValidity: indexes[${i}] not valid`),
);
}
resolve();
});
}
return Promise.resolve();
}
}

173

electron/src/electron-utils/utilsDrop.ts

@@ -11,18 +11,16 @@ import { UtilsSQLite } from './utilsSQLite';

public async getTablesNames(mDb: any): Promise<string[]> {
return new Promise(async (resolve, reject) => {
let sql: string = '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_%';";
let retArr: string[] = [];
try {
const retQuery: any[] = await this._uSQLite.queryAll(mDb, sql, []);
for (let i: number = 0; i < retQuery.length; i++) {
retArr.push(retQuery[i].name);
}
resolve(retArr);
} catch (err) {
reject(new Error(`getTablesNames: ${err.message}`));
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_%';";
const retArr: string[] = [];
try {
const retQuery: any[] = await this._uSQLite.queryAll(mDb, sql, []);
for (const query of retQuery) {
retArr.push(query.name);
}
});
return Promise.resolve(retArr);
} catch (err) {
return Promise.reject(new Error(`getTablesNames: ${err.message}`));
}
}

@@ -35,47 +33,42 @@ /**

public async dropElements(db: any, type: string): Promise<void> {
return new Promise(async (resolve, reject) => {
let msg: string = '';
switch (type) {
case 'index':
msg = 'DropIndexes';
break;
case 'trigger':
msg = 'DropTriggers';
break;
case 'table':
msg = 'DropTables';
break;
default:
reject(new Error(`DropElements: ${type} ` + 'not found'));
break;
}
// get the element's names
let stmt: string = 'SELECT name FROM sqlite_master WHERE ';
stmt += `type = '${type}' AND name NOT LIKE 'sqlite_%';`;
try {
let elements: Array<any> = await this._uSQLite.queryAll(db, stmt, []);
if (elements.length > 0) {
let upType: string = type.toUpperCase();
let statements: Array<string> = [];
for (let i: number = 0; i < elements.length; i++) {
let stmt: string = `DROP ${upType} IF EXISTS `;
stmt += `${elements[i].name};`;
statements.push(stmt);
let msg = '';
switch (type) {
case 'index':
msg = 'DropIndexes';
break;
case 'trigger':
msg = 'DropTriggers';
break;
case 'table':
msg = 'DropTables';
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}' AND name NOT LIKE 'sqlite_%';`;
try {
const elements: any[] = await this._uSQLite.queryAll(db, stmt, []);
if (elements.length > 0) {
const upType: string = type.toUpperCase();
const statements: string[] = [];
for (const elem of elements) {
let stmt = `DROP ${upType} IF EXISTS `;
stmt += `${elem.name};`;
statements.push(stmt);
}
for (const stmt of statements) {
const lastId: number = await this._uSQLite.prepareRun(db, stmt, []);
if (lastId < 0) {
return Promise.reject(new Error(`${msg}: lastId < 0`));
}
for (let i: number = 0; i < statements.length; i++) {
const lastId: number = await this._uSQLite.prepareRun(
db,
statements[i],
[],
);
if (lastId < 0) {
reject(new Error(`${msg}: lastId < 0`));
}
}
}
resolve();
} catch (err) {
reject(new Error(`${msg}: ${err.message}`));
}
});
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`${msg}: ${err.message}`));
}
}

@@ -88,17 +81,15 @@ /**

public async dropAll(db: any): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
// drop tables
await this.dropElements(db, 'table');
// drop indexes
await this.dropElements(db, 'index');
// drop triggers
await this.dropElements(db, 'trigger');
// vacuum the database
await this._uSQLite.prepareRun(db, 'VACUUM;', []);
resolve();
} catch (err) {
reject(new Error(`DropAll: ${err.message}`));
}
});
try {
// drop tables
await this.dropElements(db, 'table');
// drop indexes
await this.dropElements(db, 'index');
// drop triggers
await this.dropElements(db, 'trigger');
// vacuum the database
await this._uSQLite.prepareRun(db, 'VACUUM;', []);
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`DropAll: ${err.message}`));
}
}

@@ -114,24 +105,22 @@ /**

): Promise<void> {
return new Promise(async (resolve, reject) => {
const tempTables: Array<string> = Object.keys(alterTables);
const statements: Array<string> = [];
for (let i: number = 0; i < tempTables.length; i++) {
let stmt = 'DROP TABLE IF EXISTS ';
stmt += `_temp_${tempTables[i]};`;
statements.push(stmt);
const tempTables: string[] = Object.keys(alterTables);
const statements: string[] = [];
for (const tTable of tempTables) {
let stmt = 'DROP TABLE IF EXISTS ';
stmt += `_temp_${tTable};`;
statements.push(stmt);
}
try {
const changes: number = await this._uSQLite.execute(
db,
statements.join('\n'),
);
if (changes < 0) {
return Promise.reject(new Error('DropTempTables: changes < 0'));
}
try {
const changes: number = await this._uSQLite.execute(
db,
statements.join('\n'),
);
if (changes < 0) {
reject(new Error('DropTempTables: changes < 0'));
}
resolve();
} catch (err) {
reject(new Error(`DropTempTables: ${err.message}`));
}
});
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`DropTempTables: ${err.message}`));
}
}
}

59

electron/src/electron-utils/utilsEncryption.ts
import { UtilsFile } from './utilsFile';
import { UtilsSQLite } from './utilsSQLite';
//1234567890123456789012345678901234567890123456789012345678901234567890
export class UtilsEncryption {

@@ -14,27 +13,27 @@ private _uFile: UtilsFile = new UtilsFile();

*/
public encryptDatabase(pathDB: string, password: string): Promise<void> {
return new Promise(async (resolve, reject) => {
const msg: string = 'EncryptDatabase: ';
let retB: boolean = this._uFile.isPathExists(pathDB);
if (retB) {
let tempPath: string = this._uFile.getFilePath('temp.db');
try {
await this._uFile.renameFilePath(pathDB, tempPath);
const oDB = await this._uSQLite.openOrCreateDatabase(tempPath, '');
const mDB = await this._uSQLite.openOrCreateDatabase(
pathDB,
password,
);
await this.sqlcipherEncrypt(oDB, pathDB, password);
oDB.close();
this._uFile.deleteFilePath(tempPath);
mDB.close();
resolve();
} catch (err) {
reject(new Error(`${msg} ${err.message} `));
}
} else {
reject(new Error(`${msg}file path ${pathDB} ` + 'does not exist'));
public async encryptDatabase(
pathDB: string,
password: string,
): Promise<void> {
const msg = 'EncryptDatabase: ';
const retB: boolean = this._uFile.isPathExists(pathDB);
if (retB) {
const tempPath: string = this._uFile.getFilePath('temp.db');
try {
await this._uFile.renameFilePath(pathDB, tempPath);
const oDB = await this._uSQLite.openOrCreateDatabase(tempPath, '');
const mDB = await this._uSQLite.openOrCreateDatabase(pathDB, password);
await this.sqlcipherEncrypt(oDB, pathDB, password);
oDB.close();
this._uFile.deleteFilePath(tempPath);
mDB.close();
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`${msg} ${err.message} `));
}
});
} else {
return Promise.reject(
new Error(`${msg}file path ${pathDB} ` + 'does not exist'),
);
}
}

@@ -47,3 +46,3 @@ /**

*/
private sqlcipherEncrypt(
private async sqlcipherEncrypt(
oDB: any,

@@ -53,3 +52,3 @@ pathDB: string,

): Promise<void> {
return new Promise(async resolve => {
try {
oDB.serialize(() => {

@@ -62,5 +61,7 @@ let stmt = `ATTACH DATABASE '${pathDB}' `;

});
resolve();
});
return Promise.resolve();
} catch (err) {
return Promise.reject(err);
}
}
}

322

electron/src/electron-utils/utilsFile.ts

@@ -0,9 +1,12 @@

// eslint-disable-next-line @typescript-eslint/no-var-requires
const app = require('electron').remote.app;
export class UtilsFile {
pathDB: string = 'Databases';
pathDB = 'Databases';
Path: any = null;
NodeFs: any = null;
Os: any = null;
AppName: string = '';
HomeDir: string = '';
appPath: string = null;
AppName = '';
HomeDir = '';
appPath: string;
osType: string;

@@ -16,5 +19,4 @@

this.HomeDir = this.Os.homedir();
const app = require('electron').remote.app;
this.appPath = app.getAppPath();
let sep: string = '/';
let sep = '/';
const idx: number = this.appPath.indexOf('\\');

@@ -34,3 +36,3 @@ if (idx != -1) sep = '\\';

public isPathExists(filePath: string): boolean {
let ret: boolean = false;
let ret = false;
try {

@@ -51,3 +53,3 @@ if (this.NodeFs.existsSync(filePath)) {

public isFileExists(fileName: string): boolean {
let ret: boolean = false;
let ret = false;
const filePath: string = this.getFilePath(fileName);

@@ -73,6 +75,6 @@ if (filePath.length > 0) {

public getDatabasesPath(): string {
let retPath: string = '';
let retPath = '';
const dbFolder: string = this.pathDB;
if (this.AppName == null || this.AppName.length === 0) {
let sep: string = '/';
let sep = '/';
const idx: number = __dirname.indexOf('\\');

@@ -111,4 +113,4 @@ if (idx != -1) sep = '\\';

public getAssetsDatabasesPath(): string {
let retPath: string = '';
let sep: string = '/';
let retPath = '';
let sep = '/';
const idx: number = __dirname.indexOf('\\');

@@ -142,11 +144,9 @@ if (idx != -1) sep = '\\';

*/
public getFileList(path: string): Promise<string[]> {
return new Promise(async resolve => {
const filenames = this.NodeFs.readdirSync(path);
let dbs: string[] = [];
filenames.forEach((file: string) => {
if (this.Path.extname(file) == '.db') dbs.push(file);
});
resolve(dbs);
public async getFileList(path: string): Promise<string[]> {
const filenames = this.NodeFs.readdirSync(path);
const dbs: string[] = [];
filenames.forEach((file: string) => {
if (this.Path.extname(file) == '.db') dbs.push(file);
});
return Promise.resolve(dbs);
}

@@ -158,9 +158,10 @@ /**

*/
public copyFromAssetToDatabase(db: string, toDb: string): Promise<void> {
return new Promise(async resolve => {
const pAsset: string = this.Path.join(this.getAssetsDatabasesPath(), db);
const pDb: string = this.Path.join(this.getDatabasesPath(), toDb);
await this.copyFilePath(pAsset, pDb);
resolve();
});
public async copyFromAssetToDatabase(
db: string,
toDb: string,
): Promise<void> {
const pAsset: string = this.Path.join(this.getAssetsDatabasesPath(), db);
const pDb: string = this.Path.join(this.getDatabasesPath(), toDb);
await this.copyFilePath(pAsset, pDb);
return Promise.resolve();
}

@@ -173,18 +174,21 @@ /**

*/
public copyFileName(fileName: string, toFileName: string): Promise<void> {
return new Promise(async (resolve, reject) => {
// get File Paths
const filePath = this.getFilePath(fileName);
const toFilePath = this.getFilePath(toFileName);
if (filePath.length !== 0 && toFilePath.length !== 0) {
try {
await this.copyFilePath(filePath, toFilePath);
resolve();
} catch (err) {
reject(new Error(`CopyFileName: ${err.message}`));
}
} else {
reject(new Error('CopyFileName: cannot get the ' + 'filePath'));
public async copyFileName(
fileName: string,
toFileName: string,
): Promise<void> {
// get File Paths
const filePath = this.getFilePath(fileName);
const toFilePath = this.getFilePath(toFileName);
if (filePath.length !== 0 && toFilePath.length !== 0) {
try {
await this.copyFilePath(filePath, toFilePath);
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`CopyFileName: ${err.message}`));
}
});
} else {
return Promise.reject(
new Error('CopyFileName: cannot get the ' + 'filePath'),
);
}
}

@@ -197,22 +201,27 @@ /**

*/
public copyFilePath(filePath: string, toFilePath: string): Promise<void> {
return new Promise(async (resolve, reject) => {
if (filePath.length !== 0 && toFilePath.length !== 0) {
// check filePath exists
const isPath = this.isPathExists(filePath);
if (isPath) {
try {
await this.deleteFilePath(toFilePath);
this.NodeFs.copyFileSync(filePath, toFilePath);
resolve();
} catch (err) {
reject(new Error(`CopyFilePath: ${err.message}`));
}
} else {
reject(new Error('CopyFilePath: filePath does not ' + 'exist'));
public async copyFilePath(
filePath: string,
toFilePath: string,
): Promise<void> {
if (filePath.length !== 0 && toFilePath.length !== 0) {
// check filePath exists
const isPath = this.isPathExists(filePath);
if (isPath) {
try {
await this.deleteFilePath(toFilePath);
this.NodeFs.copyFileSync(filePath, toFilePath);
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`CopyFilePath: ${err.message}`));
}
} else {
reject(new Error('CopyFilePath: cannot get the ' + 'filePath'));
return Promise.reject(
new Error('CopyFilePath: filePath does not ' + 'exist'),
);
}
});
} else {
return Promise.reject(
new Error('CopyFilePath: cannot get the ' + 'filePath'),
);
}
}

@@ -224,21 +233,21 @@ /**

*/
public deleteFileName(fileName: string): Promise<void> {
return new Promise(async (resolve, reject) => {
// get file path
const filePath = this.getFilePath(fileName);
if (filePath.length !== 0) {
try {
await this.deleteFilePath(filePath);
resolve();
} catch (err) {
reject(
new Error(
'DeleteFileName: delete filePath ' + `failed ${err.message}`,
),
);
}
} else {
reject(new Error('DeleteFileName: get filePath ' + 'failed'));
public async deleteFileName(fileName: string): Promise<void> {
// get file path
const filePath = this.getFilePath(fileName);
if (filePath.length !== 0) {
try {
await this.deleteFilePath(filePath);
return Promise.resolve();
} catch (err) {
return Promise.reject(
new Error(
'DeleteFileName: delete filePath ' + `failed ${err.message}`,
),
);
}
});
} else {
return Promise.reject(
new Error('DeleteFileName: get filePath ' + 'failed'),
);
}
}

@@ -250,21 +259,23 @@ /**

*/
public deleteFilePath(filePath: string): Promise<void> {
return new Promise((resolve, reject) => {
if (filePath.length !== 0) {
// check if path exists
const isPath = this.isPathExists(filePath);
if (isPath) {
try {
this.NodeFs.unlinkSync(filePath);
resolve();
} catch (err) {
reject(new Error('DeleteFilePath: ' + `${err.message}`));
}
} else {
resolve();
public async deleteFilePath(filePath: string): Promise<void> {
if (filePath.length !== 0) {
// check if path exists
const isPath = this.isPathExists(filePath);
if (isPath) {
try {
this.NodeFs.unlinkSync(filePath);
return Promise.resolve();
} catch (err) {
return Promise.reject(
new Error('DeleteFilePath: ' + `${err.message}`),
);
}
} else {
reject(new Error('DeleteFilePath: delete filePath' + 'failed'));
return Promise.resolve();
}
});
} else {
return Promise.reject(
new Error('DeleteFilePath: delete filePath' + 'failed'),
);
}
}

@@ -276,18 +287,21 @@ /**

*/
public renameFileName(fileName: string, toFileName: string): Promise<void> {
return new Promise(async (resolve, reject) => {
// get File Paths
const filePath = this.getFilePath(fileName);
const toFilePath = this.getFilePath(toFileName);
if (filePath.length !== 0 && toFilePath.length !== 0) {
try {
await this.renameFilePath(filePath, toFilePath);
resolve();
} catch (err) {
reject(new Error(`RenameFileName: ${err.message}`));
}
} else {
reject(new Error('RenameFileName: filePaths do not ' + 'exist'));
public async renameFileName(
fileName: string,
toFileName: string,
): Promise<void> {
// get File Paths
const filePath = this.getFilePath(fileName);
const toFilePath = this.getFilePath(toFileName);
if (filePath.length !== 0 && toFilePath.length !== 0) {
try {
await this.renameFilePath(filePath, toFilePath);
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`RenameFileName: ${err.message}`));
}
});
} else {
return Promise.reject(
new Error('RenameFileName: filePaths do not ' + 'exist'),
);
}
}

@@ -299,23 +313,28 @@ /**

*/
public renameFilePath(filePath: string, toFilePath: string): Promise<void> {
return new Promise(async (resolve, reject) => {
if (filePath.length !== 0 && toFilePath.length !== 0) {
// check filePath exists
const isPath = this.isPathExists(filePath);
if (isPath) {
// delete toFilePath if exists
try {
await this.deleteFilePath(toFilePath);
this.NodeFs.renameSync(filePath, toFilePath);
resolve();
} catch (err) {
reject(new Error('RenameFilePath: ' + `${err.message}`));
}
} else {
reject(new Error('RenameFilePath: filePath ' + 'does not exist'));
public async renameFilePath(
filePath: string,
toFilePath: string,
): Promise<void> {
if (filePath.length !== 0 && toFilePath.length !== 0) {
// check filePath exists
const isPath = this.isPathExists(filePath);
if (isPath) {
// delete toFilePath if exists
try {
await this.deleteFilePath(toFilePath);
this.NodeFs.renameSync(filePath, toFilePath);
return Promise.resolve();
} catch (err) {
return Promise.reject(
new Error('RenameFilePath: ' + `${err.message}`),
);
}
} else {
reject(new Error('RenameFilePath: filePath not found'));
return Promise.reject(
new Error('RenameFilePath: filePath ' + 'does not exist'),
);
}
});
} else {
return Promise.reject(new Error('RenameFilePath: filePath not found'));
}
}

@@ -327,24 +346,31 @@ /**

*/
public restoreFileName(fileName: string, prefix: string): Promise<void> {
return new Promise(async (resolve, reject) => {
const mFileName = `${prefix}-${fileName}`;
// check if file exists
const isFilePre: boolean = this.isFileExists(mFileName);
if (isFilePre) {
const isFile: boolean = this.isFileExists(fileName);
if (isFile) {
try {
await this.deleteFileName(fileName);
await this.renameFileName(mFileName, fileName);
resolve();
} catch (err) {
reject(new Error('RestoreFileName: ' + `${err.message}`));
}
} else {
reject(new Error(`RestoreFileName: ${fileName} ` + 'does not exist'));
public async restoreFileName(
fileName: string,
prefix: string,
): Promise<void> {
const mFileName = `${prefix}-${fileName}`;
// check if file exists
const isFilePre: boolean = this.isFileExists(mFileName);
if (isFilePre) {
const isFile: boolean = this.isFileExists(fileName);
if (isFile) {
try {
await this.deleteFileName(fileName);
await this.renameFileName(mFileName, fileName);
return Promise.resolve();
} catch (err) {
return Promise.reject(
new Error('RestoreFileName: ' + `${err.message}`),
);
}
} else {
reject(new Error(`RestoreFileName: ${mFileName} ` + 'does not exist'));
return Promise.reject(
new Error(`RestoreFileName: ${fileName} ` + 'does not exist'),
);
}
});
} else {
return Promise.reject(
new Error(`RestoreFileName: ${mFileName} ` + 'does not exist'),
);
}
}

@@ -375,5 +401,5 @@ /**

private _mkdirSyncRecursive(directory: string): void {
var path = directory.replace(/\/$/, '').split('/');
for (var i = 1; i <= path.length; i++) {
var segment = path.slice(0, i).join('/');
const path = directory.replace(/\/$/, '').split('/');
for (let i = 1; i <= path.length; i++) {
const segment = path.slice(0, i).join('/');
segment.length > 0 && !this.NodeFs.existsSync(segment)

@@ -380,0 +406,0 @@ ? this.NodeFs.mkdirSync(segment)

255

electron/src/electron-utils/utilsSQLite.ts
export class UtilsSQLite {
public JSQlite: any;
constructor() {
// eslint-disable-next-line @typescript-eslint/no-var-requires
this.JSQlite = require('@journeyapps/sqlcipher').verbose();

@@ -11,37 +12,38 @@ }

*/
public openOrCreateDatabase(pathDB: string, password: string): Promise<any> {
return new Promise(async (resolve, reject) => {
let msg: string = 'OpenOrCreateDatabase: ';
// open sqlite3 database
const mDB: any = new this.JSQlite.Database(pathDB, {
verbose: console.log,
});
if (mDB != null) {
try {
await this.dbChanges(mDB);
} catch (err) {
reject(new Error(msg + `dbChanges ${err.message}`));
public async openOrCreateDatabase(
pathDB: string,
password: string,
): Promise<any> {
const msg = 'OpenOrCreateDatabase: ';
// open sqlite3 database
const mDB: any = new this.JSQlite.Database(pathDB, {
verbose: console.log,
});
if (mDB != null) {
try {
await this.dbChanges(mDB);
} catch (err) {
return Promise.reject(new Error(msg + `dbChanges ${err.message}`));
}
try {
// set the password
if (password.length > 0) {
await this.setCipherPragma(mDB, password);
}
// set Foreign Keys On
await this.setForeignKeyConstraintsEnabled(mDB, true);
try {
// set the password
if (password.length > 0) {
await this.setCipherPragma(mDB, password);
}
// set Foreign Keys On
await this.setForeignKeyConstraintsEnabled(mDB, true);
// Check Version
let curVersion: number = await this.getVersion(mDB);
if (curVersion === 0) {
await this.setVersion(mDB, 1);
}
} catch (err) {
reject(new Error(msg + `${err.message}`));
// Check Version
const curVersion: number = await this.getVersion(mDB);
if (curVersion === 0) {
await this.setVersion(mDB, 1);
}
resolve(mDB);
} else {
reject(new Error(msg + 'open database failed'));
} catch (err) {
return Promise.reject(new Error(msg + `${err.message}`));
}
});
return Promise.resolve(mDB);
} else {
return Promise.reject(new Error(msg + 'open database failed'));
}
}

@@ -53,4 +55,4 @@ /**

*/
public setCipherPragma(mDB: any, password: string): Promise<void> {
return new Promise(async (resolve, reject) => {
public async setCipherPragma(mDB: any, password: string): Promise<void> {
return new Promise((resolve, reject) => {
mDB.serialize(() => {

@@ -72,8 +74,8 @@ mDB.run('PRAGMA cipher_compatibility = 4');

*/
public setForeignKeyConstraintsEnabled(
public async setForeignKeyConstraintsEnabled(
mDB: any,
toggle: boolean,
): Promise<void> {
return new Promise(async (resolve, reject) => {
var key: String = 'OFF';
return new Promise((resolve, reject) => {
let key = 'OFF';
if (toggle) {

@@ -94,6 +96,6 @@ key = 'ON';

*/
public getVersion(mDB: any): Promise<number> {
return new Promise(async (resolve, reject) => {
let version: number = 0;
const SELECT_VERSION: string = 'PRAGMA user_version;';
public async getVersion(mDB: any): Promise<number> {
return new Promise((resolve, reject) => {
let version = 0;
const SELECT_VERSION = 'PRAGMA user_version;';
mDB.get(SELECT_VERSION, [], (err: any, row: any) => {

@@ -120,4 +122,4 @@ // process the row here

*/
public setVersion(mDB: any, version: number): Promise<void> {
return new Promise(async (resolve, reject) => {
public async setVersion(mDB: any, version: number): Promise<void> {
return new Promise((resolve, reject) => {
mDB.run(`PRAGMA user_version = ${version}`, (err: any) => {

@@ -137,3 +139,3 @@ if (err) {

*/
public changePassword(
public async changePassword(
pathDB: string,

@@ -143,20 +145,34 @@ password: string,

): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
const mDB = await this.openOrCreateDatabase(pathDB, password);
mDB.serialize(() => {
mDB.run('PRAGMA cipher_compatibility = 4');
mDB.run(`PRAGMA key = '${password}'`);
mDB.run(`PRAGMA rekey = '${newpassword}'`, (err: any) => {
if (err) {
mDB.close();
reject(new Error('ChangePassword: ' + `${err.message}`));
}
mDB.close();
resolve();
});
let mDB: any;
try {
mDB = await this.openOrCreateDatabase(pathDB, password);
await this.pragmaReKey(mDB, password, newpassword);
} catch (err) {
return Promise.reject(err);
} finally {
mDB.close();
}
}
/**
* PragmaReKey
* @param mDB
* @param password
* @param newpassword
*/
private async pragmaReKey(
mDB: any,
password: string,
newpassword: string,
): Promise<void> {
return new Promise((resolve, reject) => {
mDB.serialize(() => {
mDB.run('PRAGMA cipher_compatibility = 4');
mDB.run(`PRAGMA key = '${password}'`);
mDB.run(`PRAGMA rekey = '${newpassword}'`, (err: any) => {
if (err) {
reject(new Error('ChangePassword: ' + `${err.message}`));
}
resolve();
});
} catch (err) {
reject(new Error(`ChangePassword: ${err.message}`));
}
});
});

@@ -169,9 +185,9 @@ }

*/
public beginTransaction(db: any, isOpen: boolean): Promise<void> {
public async beginTransaction(db: any, isOpen: boolean): Promise<void> {
return new Promise((resolve, reject) => {
const msg: string = 'BeginTransaction: ';
const msg = 'BeginTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
return Promise.reject(new Error(`${msg}database not opened`));
}
const sql: string = 'BEGIN TRANSACTION;';
const sql = 'BEGIN TRANSACTION;';
db.run(sql, (err: Error) => {

@@ -190,9 +206,9 @@ if (err) {

*/
public rollbackTransaction(db: any, isOpen: boolean): Promise<void> {
public async rollbackTransaction(db: any, isOpen: boolean): Promise<void> {
return new Promise((resolve, reject) => {
const msg: string = 'RollbackTransaction: ';
const msg = 'RollbackTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
const sql: string = 'ROLLBACK TRANSACTION;';
const sql = 'ROLLBACK TRANSACTION;';
db.run(sql, (err: any) => {

@@ -211,9 +227,9 @@ if (err) {

*/
public commitTransaction(db: any, isOpen: boolean): Promise<void> {
public async commitTransaction(db: any, isOpen: boolean): Promise<void> {
return new Promise((resolve, reject) => {
const msg: string = 'CommitTransaction: ';
const msg = 'CommitTransaction: ';
if (!isOpen) {
reject(new Error(`${msg}database not opened`));
}
const sql: string = 'COMMIT TRANSACTION;';
const sql = 'COMMIT TRANSACTION;';
db.run(sql, (err: any) => {

@@ -232,6 +248,6 @@ if (err) {

*/
public dbChanges(db: any): Promise<number> {
public async dbChanges(db: any): Promise<number> {
return new Promise((resolve, reject) => {
const SELECT_CHANGE: string = 'SELECT total_changes()';
let changes: number = 0;
const SELECT_CHANGE = 'SELECT total_changes()';
let changes = 0;

@@ -260,8 +276,8 @@ db.get(SELECT_CHANGE, [], (err: any, row: any) => {

return new Promise((resolve, reject) => {
const SELECT_LAST_ID: string = 'SELECT last_insert_rowid()';
let lastId: number = -1;
const SELECT_LAST_ID = 'SELECT last_insert_rowid()';
let lastId = -1;
db.get(SELECT_LAST_ID, [], (err: any, row: any) => {
// process the row here
if (err) {
let msg: string = 'GetLastId failed: ';
let msg = 'GetLastId failed: ';
msg += `${err.message}`;

@@ -283,11 +299,21 @@ reject(new Error(msg));

*/
public execute(mDB: any, sql: string): Promise<number> {
return new Promise(async (resolve, reject) => {
let changes: number = -1;
let initChanges: number = -1;
try {
initChanges = await this.dbChanges(mDB);
} catch (err) {
reject(new Error(`Execute: ${err.message}`));
}
public async execute(mDB: any, sql: string): Promise<number> {
let changes = -1;
let initChanges = -1;
try {
initChanges = await this.dbChanges(mDB);
await this.execDB(mDB, sql);
changes = (await this.dbChanges(mDB)) - initChanges;
return Promise.resolve(changes);
} catch (err) {
return Promise.reject(new Error(`Execute: ${err.message}`));
}
}
/**
* ExecDB
* @param mDB
* @param sql
*/
private async execDB(mDB: any, sql: string): Promise<void> {
return new Promise((resolve, reject) => {
mDB.exec(sql, async (err: any) => {

@@ -298,8 +324,3 @@ if (err) {

}
try {
changes = (await this.dbChanges(mDB)) - initChanges;
} catch (err) {
reject(new Error(`ExecuteSQL: ${err.message}`));
}
resolve(changes);
resolve();
});

@@ -313,30 +334,26 @@ });

*/
public executeSet(db: any, set: any[]): Promise<number> {
return new Promise(async (resolve, reject) => {
let lastId: number = -1;
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 : null;
if (statement == null || values == null) {
let msg: string = 'ExecuteSet: Error statement';
msg += ` or values are null for index ${i}`;
reject(new Error(msg));
break;
}
try {
if (Array.isArray(values[0])) {
for (let j = 0; j < values.length; j++) {
lastId = await this.prepareRun(db, statement, values[j]);
}
} else {
lastId = await this.prepareRun(db, statement, values);
public async executeSet(db: any, set: any[]): Promise<number> {
let lastId = -1;
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 : null;
if (statement == null || values == null) {
let msg = 'ExecuteSet: Error statement';
msg += ` or values are null for index ${i}`;
return Promise.reject(new Error(msg));
}
try {
if (Array.isArray(values[0])) {
for (const val of values) {
lastId = await this.prepareRun(db, statement, val);
}
} catch (err) {
reject(new Error(`ExecuteSet: ${err.message}`));
break;
} else {
lastId = await this.prepareRun(db, statement, values);
}
} catch (err) {
return Promise.reject(new Error(`ExecuteSet: ${err.message}`));
}
resolve(lastId);
});
}
return Promise.resolve(lastId);
}

@@ -355,6 +372,6 @@ /**

return new Promise((resolve, reject) => {
let lastId: number = -1;
let lastId = -1;
db.run(statement, values, async (err: any) => {
if (err) {
let msg: string = `PrepareRun: run `;
let msg = `PrepareRun: run `;
msg += `${err.message}`;

@@ -367,3 +384,3 @@ reject(new Error(msg));

} catch (err) {
let msg: string = `PrepareRun: lastId `;
let msg = `PrepareRun: lastId `;
msg += `${err.message}`;

@@ -370,0 +387,0 @@ reject(new Error(msg));

463

electron/src/electron-utils/utilsUpgrade.ts

@@ -1,7 +0,7 @@

import { capSQLiteVersionUpgrade, capSQLiteSet } from '../definitions';
import type { capSQLiteVersionUpgrade, capSQLiteSet } from '../definitions';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { UtilsDrop } from './utilsDrop';
import { UtilsFile } from './utilsFile';
import { UtilsJson } from './ImportExportJson/utilsJson';
import { UtilsSQLite } from './utilsSQLite';
//1234567890123456789012345678901234567890123456789012345678901234567890

@@ -24,3 +24,3 @@ export class UtilsUpgrade {

*/
public onUpgrade(
public async onUpgrade(
mDB: any,

@@ -32,57 +32,55 @@ vUpgDict: Record<number, capSQLiteVersionUpgrade>,

): Promise<number> {
return new Promise(async (resolve, reject) => {
const upgrade: capSQLiteVersionUpgrade = vUpgDict[curVersion];
if (upgrade != null) {
const keys: string[] = Object.keys(upgrade);
if (!keys.includes('toVersion')) {
reject(new Error('onUpgrade: toVersion not given'));
}
const toVersion: number = upgrade.toVersion;
if (!keys.includes('statement')) {
reject(new Error('onUpgrade: statement not given'));
}
const statement: string = upgrade.statement;
let set: capSQLiteSet[] = [];
if (keys.includes('set')) {
set = upgrade.set!;
}
if (targetVersion < toVersion) {
let msg: string = 'Error: version mistmatch ';
msg += 'Upgrade Statement would upgrade to ';
msg += `version ${toVersion} , but target version `;
msg += `is ${targetVersion} for database ${dbName}`;
msg += ` and version ${curVersion}`;
reject(new Error(`onUpgrade: ${msg}`));
}
try {
// set Foreign Keys Off
await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, false);
await this._uFile.copyFileName(dbName, `backup-${dbName}`);
const initChanges = await this._uSQLite.dbChanges(mDB);
const upgrade: capSQLiteVersionUpgrade = vUpgDict[curVersion];
if (upgrade != null) {
const keys: string[] = Object.keys(upgrade);
if (!keys.includes('toVersion')) {
return Promise.reject(new Error('onUpgrade: toVersion not given'));
}
const toVersion: number = upgrade.toVersion;
if (!keys.includes('statement')) {
return Promise.reject(new Error('onUpgrade: statement not given'));
}
const statement: string = upgrade.statement;
let set: capSQLiteSet[] = [];
if (keys.includes('set')) {
set = upgrade.set;
}
if (targetVersion < toVersion) {
let msg = 'Error: version mistmatch ';
msg += 'Upgrade Statement would upgrade to ';
msg += `version ${toVersion} , but target version `;
msg += `is ${targetVersion} for database ${dbName}`;
msg += ` and version ${curVersion}`;
return Promise.reject(new Error(`onUpgrade: ${msg}`));
}
try {
// set Foreign Keys Off
await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, false);
await this._uFile.copyFileName(dbName, `backup-${dbName}`);
const initChanges = await this._uSQLite.dbChanges(mDB);
// Here we assume that all table schemas are given
// in the upgrade statement
if (statement.length > 0) {
await this.executeStatementProcess(mDB, statement);
// Here we assume that all table schemas are given
// in the upgrade statement
if (statement.length > 0) {
await this.executeStatementProcess(mDB, statement);
// Here we assume that the Set contains only
// - the data for new tables
// as INSERT statements
// - the data for new columns in existing tables
// as UPDATE statements
if (set.length > 0) {
await this.executeSetProcess(mDB, set, toVersion);
}
// Here we assume that the Set contains only
// - the data for new tables
// as INSERT statements
// - the data for new columns in existing tables
// as UPDATE statements
if (set.length > 0) {
await this.executeSetProcess(mDB, set, toVersion);
}
// set Foreign Keys On
await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
const changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
resolve(changes);
} catch (err) {
reject(new Error(`onUpgrade: ${err.message}`));
}
} else {
reject(new Error('onUpgrade: upgrade not found'));
// set Foreign Keys On
await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
const changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
return Promise.resolve(changes);
} catch (err) {
return Promise.reject(new Error(`onUpgrade: ${err.message}`));
}
});
} else {
return Promise.reject(new Error('onUpgrade: upgrade not found'));
}
}

@@ -94,37 +92,42 @@ /**

*/
private executeStatementProcess(mDB: any, statement: string): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
// -> backup all existing tables "tableName" in
// "temp_tableName"
await this.backupTables(mDB);
private async executeStatementProcess(
mDB: any,
statement: string,
): Promise<void> {
try {
// -> backup all existing tables "tableName" in
// "temp_tableName"
await this.backupTables(mDB);
// -> Drop all Indexes
await this._uDrop.dropElements(mDB, 'index');
// -> Drop all Triggers
await this._uDrop.dropElements(mDB, 'trigger');
// -> Drop all Indexes
await this._uDrop.dropElements(mDB, 'index');
// -> Drop all Triggers
await this._uDrop.dropElements(mDB, 'trigger');
// -> Create new tables from upgrade.statement
const changes: number = await this._uSQLite.execute(mDB, statement);
if (changes < 0) {
reject(new Error('ExecuteStatementProcess: ' + 'changes < 0'));
}
// -> Create the list of table's common fields
await this.findCommonColumns(mDB);
// -> Create new tables from upgrade.statement
const changes: number = await this._uSQLite.execute(mDB, statement);
if (changes < 0) {
return Promise.reject(
new Error('ExecuteStatementProcess: ' + 'changes < 0'),
);
}
// -> Create the list of table's common fields
await this.findCommonColumns(mDB);
// -> Update the new table's data from old table's data
if (Object.keys(this._commonColumns).length > 0) {
await this.updateNewTablesData(mDB);
}
// -> Update the new table's data from old table's data
if (Object.keys(this._commonColumns).length > 0) {
await this.updateNewTablesData(mDB);
}
// -> Drop _temp_tables
await this._uDrop.dropTempTables(mDB, this._alterTables);
// -> Do some cleanup
this._alterTables = {};
this._commonColumns = {};
resolve();
} catch (err) {
reject(new Error(`ExecuteStatementProcess: ${err.message}`));
}
});
// -> Drop _temp_tables
await this._uDrop.dropTempTables(mDB, this._alterTables);
// -> Do some cleanup
this._alterTables = {};
this._commonColumns = {};
return Promise.resolve();
} catch (err) {
return Promise.reject(
new Error(`ExecuteStatementProcess: ${err.message}`),
);
}
}

@@ -137,3 +140,3 @@ /**

*/
private executeSetProcess(
private async executeSetProcess(
mDB: any,

@@ -143,27 +146,27 @@ set: capSQLiteSet[],

): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
// -> load new data
const lastId = await this._uSQLite.executeSet(mDB, set);
if (lastId < 0) {
reject(new Error('ExecuteSetProcess: lastId ' + '< 0'));
try {
// -> load new data
const lastId = await this._uSQLite.executeSet(mDB, set);
if (lastId < 0) {
return Promise.reject(new Error('ExecuteSetProcess: lastId ' + '< 0'));
}
// -> update database version
await this._uSQLite.setVersion(mDB, toVersion);
// -> update syncDate if any
const retB = await this._uJson.isTableExists(mDB, true, 'sync_table');
if (retB) {
const sDate: number = Math.round(new Date().getTime() / 1000);
let stmt = 'UPDATE sync_table SET ';
stmt += `sync_date = ${sDate} WHERE id = 1;`;
const changes: number = await this._uSQLite.execute(mDB, stmt);
if (changes < 0) {
return Promise.reject(
new Error('ExecuteSetProcess: changes ' + '< 0'),
);
}
// -> update database version
await this._uSQLite.setVersion(mDB, toVersion);
// -> update syncDate if any
const retB = await this._uJson.isTableExists(mDB, true, 'sync_table');
if (retB) {
const sDate: number = Math.round(new Date().getTime() / 1000);
let stmt: string = 'UPDATE sync_table SET ';
stmt += `sync_date = ${sDate} WHERE id = 1;`;
const changes: number = await this._uSQLite.execute(mDB, stmt);
if (changes < 0) {
reject(new Error('ExecuteSetProcess: changes ' + '< 0'));
}
}
resolve();
} catch (err) {
reject(new Error(`ExecuteSetProcess: ${err.message}`));
}
});
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`ExecuteSetProcess: ${err.message}`));
}
}

@@ -174,19 +177,19 @@ /**

*/
private backupTables(mDB: any): Promise<void> {
return new Promise(async (resolve, reject) => {
const msg: string = 'BackupTables: ';
try {
const tables: string[] = await this._uDrop.getTablesNames(mDB);
for (let i: number = 0; i < tables.length; i++) {
try {
await this.backupTable(mDB, tables[i]);
} catch (err) {
reject(new Error(`${msg}table ${tables[i]}: ` + `${err.message}`));
}
private async backupTables(mDB: any): Promise<void> {
const msg = 'BackupTables: ';
try {
const tables: string[] = await this._uDrop.getTablesNames(mDB);
for (const table of tables) {
try {
await this.backupTable(mDB, table);
} catch (err) {
return Promise.reject(
new Error(`${msg}table ${table}: ` + `${err.message}`),
);
}
resolve();
} catch (err) {
reject(new Error(`BackupTables: ${err.message}`));
}
});
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`BackupTables: ${err.message}`));
}
}

@@ -198,34 +201,32 @@ /**

*/
private backupTable(mDB: any, table: string): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
// get the table's column names
const colNames: string[] = await this.getTableColumnNames(mDB, table);
this._alterTables[`${table}`] = colNames;
// prefix the table with _temp_
let stmt: string = `ALTER TABLE ${table} RENAME `;
stmt += `TO _temp_${table};`;
const lastId: number = await this._uSQLite.prepareRun(mDB, stmt, []);
if (lastId < 0) {
let msg: string = 'BackupTable: lastId < 0';
try {
await this._uSQLite.rollbackTransaction(mDB, true);
} catch (err) {
msg += `: ${err.message}`;
}
reject(new Error(`${msg}`));
} else {
try {
await this._uSQLite.commitTransaction(mDB, true);
} catch (err) {
reject(new Error('BackupTable: ' + `${err.message}`));
}
private async backupTable(mDB: any, table: string): Promise<void> {
try {
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
// get the table's column names
const colNames: string[] = await this.getTableColumnNames(mDB, table);
this._alterTables[`${table}`] = colNames;
// prefix the table with _temp_
let stmt = `ALTER TABLE ${table} RENAME `;
stmt += `TO _temp_${table};`;
const lastId: number = await this._uSQLite.prepareRun(mDB, stmt, []);
if (lastId < 0) {
let msg = 'BackupTable: lastId < 0';
try {
await this._uSQLite.rollbackTransaction(mDB, true);
} catch (err) {
msg += `: ${err.message}`;
}
resolve();
} catch (err) {
reject(new Error(`BackupTable: ${err.message}`));
return Promise.reject(new Error(`${msg}`));
} else {
try {
await this._uSQLite.commitTransaction(mDB, true);
} catch (err) {
return Promise.reject(new Error('BackupTable: ' + `${err.message}`));
}
}
});
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`BackupTable: ${err.message}`));
}
}

@@ -237,19 +238,22 @@ /**

*/
private getTableColumnNames(mDB: any, tableName: string): Promise<string[]> {
return new Promise(async (resolve, reject) => {
let resQuery: any[] = [];
let retNames: string[] = [];
const query: string = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await this._uSQLite.queryAll(mDB, query, []);
if (resQuery.length > 0) {
for (let i: number = 0; i < resQuery.length; i++) {
retNames.push(resQuery[i].name);
}
private async getTableColumnNames(
mDB: any,
tableName: string,
): Promise<string[]> {
let resQuery: any[] = [];
const retNames: string[] = [];
const query = `PRAGMA table_info('${tableName}');`;
try {
resQuery = await this._uSQLite.queryAll(mDB, query, []);
if (resQuery.length > 0) {
for (const query of resQuery) {
retNames.push(query.name);
}
resolve(retNames);
} catch (err) {
reject(new Error('GetTableColumnNames: ' + `${err.message}`));
}
});
return Promise.resolve(retNames);
} catch (err) {
return Promise.reject(
new Error('GetTableColumnNames: ' + `${err.message}`),
);
}
}

@@ -261,29 +265,26 @@ /**

private async findCommonColumns(mDB: any): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
// Get new table list
const tables: Array<any> = await this._uDrop.getTablesNames(mDB);
if (tables.length === 0) {
reject(new Error('FindCommonColumns: get ' + "table's names failed"));
}
for (let i: number = 0; i < tables.length; i++) {
// get the column's name
const tableNames: any = await this.getTableColumnNames(
mDB,
tables[i],
try {
// Get new table list
const tables: any[] = await this._uDrop.getTablesNames(mDB);
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: any = await this.getTableColumnNames(mDB, table);
// find the common columns
const keys: string[] = Object.keys(this._alterTables);
if (keys.includes(table)) {
this._commonColumns[table] = this.arraysIntersection(
this._alterTables[table],
tableNames,
);
// find the common columns
const keys: Array<string> = Object.keys(this._alterTables);
if (keys.includes(tables[i])) {
this._commonColumns[tables[i]] = this.arraysIntersection(
this._alterTables[tables[i]],
tableNames,
);
}
}
resolve();
} catch (err) {
reject(new Error(`FindCommonColumns: ${err.message}`));
}
});
return Promise.resolve();
} catch (err) {
return Promise.reject(new Error(`FindCommonColumns: ${err.message}`));
}
}

@@ -295,3 +296,3 @@ /**

*/
private arraysIntersection(a1: Array<any>, a2: Array<any>): Array<any> {
private arraysIntersection(a1: any[], a2: any[]): any[] {
if (a1 != null && a2 != null) {

@@ -309,42 +310,44 @@ const first = new Set(a1);

*/
private updateNewTablesData(mDB: any): Promise<void> {
return new Promise(async (resolve, reject) => {
try {
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
private async updateNewTablesData(mDB: any): Promise<void> {
try {
// start a transaction
await this._uSQLite.beginTransaction(mDB, true);
let statements: string[] = [];
const keys: string[] = Object.keys(this._commonColumns);
keys.forEach(key => {
const columns = this._commonColumns[key].join(',');
let stmt: string = `INSERT INTO ${key} `;
stmt += `(${columns}) `;
stmt += `SELECT ${columns} FROM _temp_${key};`;
statements.push(stmt);
});
const changes: number = await this._uSQLite.execute(
mDB,
statements.join('\n'),
);
if (changes < 0) {
let msg: string = 'updateNewTablesData: ' + 'changes < 0';
try {
await this._uSQLite.rollbackTransaction(mDB, true);
} catch (err) {
msg += `: ${err.message}`;
}
reject(new Error(`${msg}`));
} else {
try {
await this._uSQLite.commitTransaction(mDB, true);
resolve();
} catch (err) {
reject(new Error('updateNewTablesData: ' + `${err.message}`));
}
const statements: string[] = [];
const keys: string[] = Object.keys(this._commonColumns);
keys.forEach(key => {
const columns = this._commonColumns[key].join(',');
let stmt = `INSERT INTO ${key} `;
stmt += `(${columns}) `;
stmt += `SELECT ${columns} FROM _temp_${key};`;
statements.push(stmt);
});
const changes: number = await this._uSQLite.execute(
mDB,
statements.join('\n'),
);
if (changes < 0) {
let msg: string = 'updateNewTablesData: ' + 'changes < 0';
try {
await this._uSQLite.rollbackTransaction(mDB, true);
} catch (err) {
msg += `: ${err.message}`;
}
} catch (err) {
reject(new Error('updateNewTablesData: ' + `${err.message}`));
return Promise.reject(new Error(`${msg}`));
} else {
try {
await this._uSQLite.commitTransaction(mDB, true);
return Promise.resolve();
} catch (err) {
return Promise.reject(
new Error('updateNewTablesData: ' + `${err.message}`),
);
}
}
});
} catch (err) {
return Promise.reject(
new Error('updateNewTablesData: ' + `${err.message}`),
);
}
}
}

4

electron/src/GlobalSQLite.ts
export class GlobalSQLite {
public secret: string = 'sqlite secret';
public newsecret: string = 'sqlite new secret';
public secret = 'sqlite secret';
public newsecret = 'sqlite new secret';
}

473

electron/src/plugin.ts
import { WebPlugin } from '@capacitor/core';
import {
import type {
CapacitorSQLitePlugin,

@@ -25,8 +26,8 @@ capConnectionOptions,

import { Database } from './electron-utils/Database';
import { UtilsJson } from './electron-utils/ImportExportJson/utilsJson';
import { UtilsFile } from './electron-utils/utilsFile';
import { UtilsJson } from './electron-utils/ImportExportJson/utilsJson';
//1234567890123456789012345678901234567890123456789012345678901234567890
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { remote } = require('electron');
const { remote } = require('electron');
export class CapacitorSQLiteElectronWeb

@@ -54,13 +55,8 @@ extends WebPlugin

}
async createConnection(
options: capConnectionOptions,
): Promise<capSQLiteResult> {
async createConnection(options: capConnectionOptions): Promise<void> {
const keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
const version: number = options.version ? options.version : 1;

@@ -80,3 +76,3 @@ const encrypted: boolean =

}
let mDb: Database = new Database(
const mDb: Database = new Database(
dbName + 'SQLite.db',

@@ -89,22 +85,17 @@ encrypted,

this._dbDict[dbName] = mDb;
return Promise.resolve({ result: true });
return Promise.resolve();
}
async closeConnection(options: capSQLiteOptions): Promise<capSQLiteResult> {
async closeConnection(options: capSQLiteOptions): Promise<void> {
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message:
'CloseConnection command failed: No ' +
return Promise.reject(
'CloseConnection command failed: No ' +
'available connection for ' +
dbName,
});
);
}

@@ -118,6 +109,4 @@

} catch (err) {
return Promise.resolve({
result: false,
message:
'CloseConnection command failed: ' +
return Promise.reject(
'CloseConnection command failed: ' +
'close ' +

@@ -127,3 +116,3 @@ dbName +

err.message,
});
);
}

@@ -133,3 +122,3 @@ }

delete this._dbDict[dbName];
return Promise.resolve({ result: true });
return Promise.resolve();
}

@@ -140,19 +129,13 @@

ret.value = options.value;
return ret;
return Promise.resolve(ret);
}
async open(options: capSQLiteOptions): Promise<capSQLiteResult> {
async open(options: capSQLiteOptions): Promise<void> {
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: `Open: No available connection for ${dbName}`,
});
return Promise.reject(`Open: No available connection for ${dbName}`);
}

@@ -163,25 +146,16 @@

await mDB.open();
return Promise.resolve({ result: true });
return Promise.resolve();
} catch (err) {
return Promise.resolve({
result: false,
message: `Open: ${err.message}`,
});
return Promise.reject(`Open: ${err.message}`);
}
}
async close(options: capSQLiteOptions): Promise<capSQLiteResult> {
async close(options: capSQLiteOptions): Promise<void> {
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: `Close: No available connection for ${dbName}`,
});
return Promise.reject(`Close: No available connection for ${dbName}`);
}

@@ -192,8 +166,5 @@

await mDB.close();
return Promise.resolve({ result: true });
return Promise.resolve();
} catch (err) {
return Promise.resolve({
result: false,
message: `Close: ${err.message}`,
});
return Promise.reject(`Close: ${err.message}`);
}

@@ -204,21 +175,12 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('statements') || options.statements!.length === 0) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide raw SQL statements',
});
if (!keys.includes('statements') || options.statements.length === 0) {
return Promise.reject('Must provide raw SQL statements');
}
const dbName: string = options.database!;
const statements: string = options.statements!;
const dbName: string = options.database;
const statements: string = options.statements;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1 },
message: `Execute: No available connection for ${dbName}`,
});
return Promise.reject(`Execute: No available connection for ${dbName}`);
}

@@ -229,6 +191,3 @@ const mDB = this._dbDict[dbName];

if (ret < 0) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Execute failed',
});
return Promise.reject('Execute failed changes < 0');
} else {

@@ -238,6 +197,3 @@ return Promise.resolve({ changes: { changes: ret } });

} catch (err) {
return Promise.resolve({
changes: { changes: -1 },
message: `Execute failed: ${err}`,
});
return Promise.reject(`Execute failed: ${err}`);
}

@@ -248,35 +204,22 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('set') || options.set!.length === 0) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a non-empty set of SQL ' + 'statements',
});
if (!keys.includes('set') || options.set.length === 0) {
return Promise.reject('Must provide a non-empty set of SQL statements');
}
const dbName: string = options.database!;
const setOfStatements: Array<any> = options.set!;
const dbName: string = options.database;
const setOfStatements: any[] = options.set;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1 },
message: `ExecuteSet: No available connection for ${dbName}`,
});
return Promise.reject(
`ExecuteSet: No available connection for ${dbName}`,
);
}
const mDB = this._dbDict[dbName];
for (let i = 0; i < setOfStatements.length; i++) {
if (
!('statement' in setOfStatements[i]) ||
!('values' in setOfStatements[i])
) {
return Promise.reject({
changes: { changes: -1 },
message:
'ExecuteSet: Must provide a set as ' +
'Array of {statement,values}',
});
for (const sStmt of setOfStatements) {
if (!('statement' in sStmt) || !('values' in sStmt)) {
return Promise.reject(
'ExecuteSet: Must provide a set as ' + 'Array of {statement,values}',
);
}

@@ -287,6 +230,3 @@ }

if (ret < 0) {
return Promise.resolve({
changes: { changes: -1 },
message: `ExecuteSet failed`,
});
return Promise.reject(`ExecuteSet failed changes <0`);
} else {

@@ -296,6 +236,3 @@ return Promise.resolve({ changes: ret });

} catch (err) {
return Promise.resolve({
changes: { changes: -1 },
message: `ExecuteSet failed: ${err}`,
});
return Promise.reject(`ExecuteSet failed: ${err}`);
}

@@ -306,29 +243,16 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('statement') || options.statement!.length === 0) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: 'Must provide a query statement',
});
if (!keys.includes('statement') || options.statement.length === 0) {
return Promise.reject('Must provide a query statement');
}
if (!keys.includes('values')) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: 'Must provide an Array of values',
});
return Promise.reject('Must provide an Array of values');
}
const dbName: string = options.database!;
const statement: string = options.statement!;
const values: Array<any> =
options.values!.length > 0 ? options.values! : [];
const dbName: string = options.database;
const statement: string = options.statement;
const values: any[] = options.values.length > 0 ? options.values : [];
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: `Run: No available connection for ${dbName}`,
});
return Promise.reject(`Run: No available connection for ${dbName}`);
}

@@ -340,6 +264,3 @@ const mDB = this._dbDict[dbName];

} catch (err) {
return Promise.resolve({
changes: { changes: -1, lastId: -1 },
message: `RUN failed: ${err} `,
});
return Promise.reject(`RUN failed: ${err} `);
}

@@ -350,29 +271,16 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
values: [],
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('statement') || options.statement!.length === 0) {
return Promise.resolve({
values: [],
message: 'Must provide a query statement',
});
if (!keys.includes('statement') || options.statement.length === 0) {
return Promise.reject('Must provide a query statement');
}
if (!keys.includes('values')) {
return Promise.resolve({
values: [],
message: 'Must provide an Array of strings',
});
return Promise.reject('Must provide an Array of strings');
}
const dbName: string = options.database!;
const statement: string = options.statement!;
const values: Array<string> =
options.values!.length > 0 ? options.values! : [];
const dbName: string = options.database;
const statement: string = options.statement;
const values: string[] = options.values.length > 0 ? options.values : [];
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
values: [],
message: `Query: No available connection for ${dbName}`,
});
return Promise.reject(`Query: No available connection for ${dbName}`);
}

@@ -385,3 +293,3 @@ const mDB = this._dbDict[dbName];

} catch (err) {
return Promise.resolve({ values: [], message: `Query failed: ${err}` });
return Promise.reject(`Query failed: ${err}`);
}

@@ -392,17 +300,10 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message:
'IsDBExists command failed: No available ' +
'connection for ' +
dbName,
});
return Promise.reject(
'IsDBExists command failed: No available ' + 'connection for ' + dbName,
);
}

@@ -414,17 +315,13 @@ const isExists: boolean = this._uFile.isFileExists(dbName + 'SQLite.db');

}
async deleteDatabase(options: capSQLiteOptions): Promise<capSQLiteResult> {
async deleteDatabase(options: capSQLiteOptions): Promise<void> {
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: 'deleteDatabase: No available connection for ' + `${dbName}`,
});
return Promise.reject(
'deleteDatabase: No available connection for ' + `${dbName}`,
);
}

@@ -435,17 +332,11 @@

await mDB.deleteDB(dbName + 'SQLite.db');
return Promise.resolve({ result: true });
return Promise.resolve();
} catch (err) {
return Promise.resolve({
result: false,
message: `Delete: ${err.message}`,
});
return Promise.reject(`Delete: ${err.message}`);
}
}
async isJsonValid(options: capSQLiteImportOptions): Promise<capSQLiteResult> {
let keys = Object.keys(options);
const keys = Object.keys(options);
if (!keys.includes('jsonstring')) {
return Promise.resolve({
result: false,
message: 'Must provide a json object',
});
return Promise.reject('Must provide a json object');
}

@@ -456,6 +347,3 @@ const jsonStrObj: string = options.jsonstring;

if (!isValid) {
return Promise.resolve({
result: false,
message: 'Stringify Json Object not Valid',
});
return Promise.reject('Stringify Json Object not Valid');
} else {

@@ -468,9 +356,5 @@ return Promise.resolve({ result: true });

): Promise<capSQLiteChanges> {
const retRes = { changes: -1 };
let keys = Object.keys(options);
const keys = Object.keys(options);
if (!keys.includes('jsonstring')) {
return Promise.resolve({
changes: retRes,
message: 'Must provide a json object',
});
return Promise.reject('Must provide a json object');
}

@@ -481,9 +365,6 @@ const jsonStrObj: string = options.jsonstring;

if (!isValid) {
return Promise.resolve({
changes: retRes,
message: 'Must provide a valid JsonSQLite Object',
});
return Promise.reject('Must provide a valid JsonSQLite Object');
}
const vJsonObj: JsonSQLite = jsonObj;
const dbName: string = `${vJsonObj.database}SQLite.db`;
const dbName = `${vJsonObj.database}SQLite.db`;
const dbVersion: number = vJsonObj.version ?? 1;

@@ -494,3 +375,3 @@ const encrypted: boolean = vJsonObj.encrypted ?? false;

// Create the database
let mDb: Database = new Database(dbName, encrypted, mode, dbVersion, {});
const mDb: Database = new Database(dbName, encrypted, mode, dbVersion, {});
try {

@@ -505,31 +386,20 @@ // Open the database

} catch (err) {
return Promise.resolve({
changes: retRes,
message: `ImportFromJson: ${err.message}`,
});
return Promise.reject(`ImportFromJson: ${err.message}`);
}
}
async exportToJson(options: capSQLiteExportOptions): Promise<capSQLiteJson> {
let retRes: JsonSQLite = {} as JsonSQLite;
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
export: retRes,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('jsonexportmode')) {
return Promise.resolve({
export: retRes,
message: 'Must provide a json export mode',
});
return Promise.reject('Must provide a json export mode');
}
const dbName: string = options.database!;
const dbName: string = options.database;
const exportMode: string = options.jsonexportmode;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
export: retRes,
message: 'exportToJson: No available connection for ' + `${dbName}`,
});
return Promise.reject(
'exportToJson: No available connection for ' + `${dbName}`,
);
}

@@ -541,6 +411,3 @@ const mDB = this._dbDict[dbName];

if (keys.includes('message')) {
return Promise.resolve({
export: retRes,
message: `exportToJson: ${ret.message}`,
});
return Promise.reject(`exportToJson: ${ret.message}`);
} else {

@@ -550,6 +417,3 @@ return Promise.resolve({ export: ret });

} catch (err) {
return Promise.resolve({
export: retRes,
message: `exportToJson: ${err.message}`,
});
return Promise.reject(`exportToJson: ${err.message}`);
}

@@ -560,54 +424,44 @@ }

if (!keys.includes('database')) {
return Promise.resolve({
changes: { changes: -1 },
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
changes: { changes: -1 },
message: 'CreateSyncTable: No available connection for ' + `${dbName}`,
});
return Promise.reject(
'CreateSyncTable: No available connection for ' + `${dbName}`,
);
}
const mDB = this._dbDict[dbName];
const ret: any = await mDB.createSyncTable();
if (ret.message === null) {
return Promise.resolve({ changes: ret.changes });
} else {
return Promise.resolve({ changes: ret.changes, message: ret.message });
try {
const ret: number = await mDB.createSyncTable();
return Promise.resolve({ changes: { changes: ret } });
} catch (err) {
return Promise.reject(`createSyncTable: ${err.message}`);
}
}
async setSyncDate(
options: capSQLiteSyncDateOptions,
): Promise<capSQLiteResult> {
async setSyncDate(options: capSQLiteSyncDateOptions): Promise<void> {
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('syncdate')) {
return Promise.resolve({
result: false,
message: 'Must provide a synchronization date',
});
return Promise.reject('Must provide a synchronization date');
}
const dbName: string = options.database!;
const syncDate: string = options.syncdate!;
const dbName: string = options.database;
const syncDate: string = options.syncdate;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
result: false,
message: `SetSyncDate: No available connection for ${dbName}`,
});
return Promise.reject(
`SetSyncDate: No available connection for ${dbName}`,
);
}
const mDB = this._dbDict[dbName];
const ret: any = await mDB.setSyncDate(syncDate);
console.log(`$$$ setSyncDate ${JSON.stringify(ret)}`);
return Promise.resolve(ret);
try {
await mDB.setSyncDate(syncDate);
return Promise.resolve();
} catch (err) {
return Promise.reject(`SetSyncDate: ${err.message}`);
}
}

@@ -619,38 +473,30 @@ async getSyncDate(

if (!keys.includes('database')) {
return Promise.resolve({
syncDate: 0,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
const dbName: string = options.database!;
const dbName: string = options.database;
keys = Object.keys(this._dbDict);
if (!keys.includes(dbName)) {
return Promise.resolve({
syncDate: 0,
message: `GetSyncDate: No available connection for ${dbName}`,
});
return Promise.reject(
`GetSyncDate: No available connection for ${dbName}`,
);
}
const mDB = this._dbDict[dbName];
const ret: any = await mDB.getSyncDate();
return Promise.resolve(ret);
try {
const ret: any = await mDB.getSyncDate();
return Promise.resolve(ret);
} catch (err) {
return Promise.reject(`GetSyncDate: ${err.message}`);
}
}
async addUpgradeStatement(
options: capSQLiteUpgradeOptions,
): Promise<capSQLiteResult> {
async addUpgradeStatement(options: capSQLiteUpgradeOptions): Promise<void> {
let keys = Object.keys(options);
if (!keys.includes('database')) {
return Promise.resolve({
result: false,
message: 'Must provide a database name',
});
return Promise.reject('Must provide a database name');
}
if (!keys.includes('upgrade')) {
return Promise.resolve({
result: false,
message: 'Must provide an upgrade statement',
});
return Promise.reject('Must provide an upgrade statement');
}
const dbName: string = options.database!;
const upgrade = options.upgrade![0];
const dbName: string = options.database;
const upgrade = options.upgrade[0];
keys = Object.keys(upgrade);

@@ -662,12 +508,8 @@ if (

) {
return Promise.reject({
result: false,
message: 'Must provide an upgrade ' + 'capSQLiteVersionUpgrade Object',
});
return Promise.reject(
'Must provide an upgrade capSQLiteVersionUpgrade Object',
);
}
if (typeof upgrade.fromVersion != 'number') {
return Promise.reject({
result: false,
message: 'ugrade.fromVersion must be a number',
});
return Promise.reject('ugrade.fromVersion must be a number');
}

@@ -677,5 +519,5 @@ const upgVDict: Record<number, capSQLiteVersionUpgrade> = {};

this._versionUpgrades[dbName] = upgVDict;
return Promise.resolve({ result: true });
return Promise.resolve();
}
async copyFromAssets(): Promise<capSQLiteResult> {
async copyFromAssets(): Promise<void> {
// check if the assets/database folder exists

@@ -692,3 +534,3 @@ const assetsDbPath = this._uFile.getAssetsDatabasesPath();

// for each check if the suffix SQLite.db is there or add it
let toDb: string = this._uFile.setPathSuffix(db);
const toDb: string = this._uFile.setPathSuffix(db);
toDbList.push(toDb);

@@ -698,14 +540,9 @@ // for each copy the file to the Application database folder

});
return Promise.resolve({ result: true });
return Promise.resolve();
} else {
return Promise.resolve({
result: false,
message: 'CopyFromAssets: assets/databases folder does not exist',
});
return Promise.reject(
'CopyFromAssets: assets/databases folder does not exist',
);
}
}
}
const CapacitorSQLite = new CapacitorSQLiteElectronWeb();
export { CapacitorSQLite };
import { registerWebPlugin } from '@capacitor/core';
registerWebPlugin(CapacitorSQLite);

117

package.json
{
"name": "@capacitor-community/sqlite",
"version": "2.9.5",
"description": "Capacitor SQLite Plugin",
"homepage": "https://github.com/capacitor-community/sqlite",
"main": "dist/esm/index.js",
"version": "3.0.0-beta.1",
"description": "Community plugin for native & electron SQLite databases",
"main": "dist/plugin.cjs.js",
"module": "dist/esm/index.js",
"types": "dist/esm/index.d.ts",
"unpkg": "dist/plugin.js",
"files": [
"android/src/main/",
"android/build.gradle",
"dist/",
"electron/",
"ios/Plugin/",
"CapacitorCommunitySqlite.podspec"
],
"author": "Jean Pierre Quéau",
"license": "MIT",
"repository": {
"type": "git",
"url": "git+https://github.com/capacitor-community/sqlite.git"
},
"bugs": {
"url": "https://github.com/capacitor-community/sqlite/issues"
},
"keywords": [
"capacitor",
"plugin",
"native",
"database",
"sqlite"
],
"scripts": {
"lint": "npm run prettier -- --check && npm run swiftlint -- lint",
"verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
"verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin && cd ..",
"verify:android": "cd android && ./gradlew clean build test && cd ..",
"verify:web": "npm run build",
"lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
"fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- autocorrect --format",
"eslint": "eslint . --ext ts",
"prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
"fmt": "npm run prettier -- --write && npm run swiftlint -- autocorrect",
"swiftlint": "node-swiftlint",
"build": "npm run clean && tsc && rollup -c rollup.config.js",
"build-electron": "rimraf ./electron/dist && cd ./electron && tsc && rollup --config rollup.config.js",
"clean": "rimraf ./dist",
"watch": "tsc --watch",
"docgen": "npm run docgenPlugin && npm run docgenConnection && npm run docgenDBConnection",

@@ -21,50 +47,35 @@ "docgenPlugin": "docgen --api CapacitorSQLitePlugin --output-readme docs/API.md",

"docgenDBConnection": "docgen --api ISQLiteDBConnection --output-readme docs/APIDBConnection.md",
"build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.js",
"build-electron": "rimraf ./electron/dist && cd ./electron && tsc && rollup --config rollup.config.js",
"clean": "rimraf ./dist",
"watch": "tsc --watch",
"prepublishOnly": "npm run build && npm run build-electron && npm run docgen"
},
"author": "Jean Pierre Queau",
"license": "MIT",
"devDependencies": {
"@capacitor/android": "^2.4.6",
"@capacitor/core": "^2.4.6",
"@capacitor/docgen": "0.0.14",
"@capacitor/ios": "^2.4.6",
"@capacitor/android": "next",
"@capacitor/core": "next",
"@capacitor/docgen": "^0.0.10",
"@capacitor/ios": "next",
"@ionic/eslint-config": "^0.3.0",
"@ionic/prettier-config": "^1.0.1",
"@ionic/swiftlint-config": "^1.1.2",
"@rollup/plugin-node-resolve": "^11.0.1",
"@types/node": "^14.14.19",
"electron": "^11.1.0",
"husky": "^4.3.6",
"np": "^7.2.0",
"prettier": "^2.2.1",
"prettier-plugin-java": "^1.0.1",
"pretty-quick": "^3.1.0",
"@rollup/plugin-node-resolve": "^11.1.0",
"electron": "^11.2.0",
"eslint": "^7.11.0",
"prettier": "~2.2.0",
"prettier-plugin-java": "~1.0.0",
"rimraf": "^3.0.2",
"rollup": "^2.35.1",
"rollup": "^2.32.0",
"rollup-plugin-node-resolve": "^5.2.0",
"swiftlint": "^1.0.1",
"tslib": "^2.0.3",
"typescript": "^4.0.5"
"typescript": "~4.0.5"
},
"husky": {
"hooks": {
"pre-commit": "pretty-quick --staged"
}
},
"peerDependencies": {
"@capacitor/core": "^2.4.6"
"@capacitor/core": "next"
},
"files": [
"dist/",
"ios/",
"android/",
"electron/",
"CapacitorCommunitySqlite.podspec"
],
"keywords": [
"capacitor",
"plugin",
"native",
"database",
"sqlite"
],
"prettier": "@ionic/prettier-config",
"swiftlint": "@ionic/swiftlint-config",
"eslintConfig": {
"extends": "@ionic/eslint-config/recommended"
},
"capacitor": {

@@ -80,13 +91,3 @@ "ios": {

}
},
"prettier": "@ionic/prettier-config",
"swiftlint": "@ionic/swiftlint-config",
"repository": {
"type": "git",
"url": "https://github.com/capacitor-community/sqlite"
},
"bugs": {
"url": "https://github.com/capacitor-community/sqlite/issues"
},
"dependencies": {}
}
}

63

README.md

@@ -29,4 +29,14 @@ <p align="center"><br><img src="https://user-images.githubusercontent.com/236501/85893648-1c92e880-b7a8-11ea-926d-95355b8175c7.png" width="128" height="128" /></p>

## REFACTOR 🚀 (Move to Master)
## NEXT FOR CAPACITOR 3 🚧 (Master)
The refactor release has been upgraded to `@capacitor/core@3.0.0-beta.1`.
!!! ONLY iOS and Android plugins have been upgraded !!!
The test has been achieved on:
- a [Ionic/Angular app](https://github.com/jepiqueau/angular-sqlite-app-refactor)
## REFACTOR 🚀 (Move to branch 2.9.x)
The refactor offers now (since `2.9.0-beta.1`) all the features that the previous was offering. It has been a quite heavy process, hoping that the developpers will take benefit from it.

@@ -50,3 +60,3 @@

- a [Ionic/Angular app](https://github.com/jepiqueau/angular-sqlite-app-refactor)
- a [Ionic/Angular app](https://github.com/jepiqueau/angular-sqlite-app-refactor/tree/refactor)

@@ -72,3 +82,3 @@ - a [Ionic/React app](https://github.com/jepiqueau/react-sqlite-app-starter/tree/refactor)

```bash
npm install @capacitor-community/sqlite@refactor
npm install @capacitor-community/sqlite@next
npm run build

@@ -78,3 +88,3 @@ npx cap sync

npx cap add ios
npx cap add @capacitor-community/electron
// npx cap add @capacitor-community/electron not working
```

@@ -91,27 +101,16 @@

```java
import com.getcapacitor.community.database.sqlite.CapacitorSQLite;
import com.getcapacitor.community.database.sqlite.CapacitorSQLitePlugin;
public class MainActivity extends BridgeActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
registerPlugin(CapacitorSQLitePlugin.class);
// Initializes the Bridge
this.init(
savedInstanceState,
new ArrayList<Class<? extends Plugin>>() {
{
// Additional plugins you've installed go here
// Ex: add(TotallyAwesomePlugin.class);
add(CapacitorSQLite.class);
}
}
);
}
}
}
```
### Electron
### Electron (NOT WORKING YET)

@@ -144,3 +143,3 @@ - On Electron, go to the Electron folder of YOUR_APPLICATION

### Electron
### Electron (NOT WORKING YET)

@@ -152,3 +151,3 @@ ```

When you will find issues, please report them with the `REFACTOR` word at the start of the issue title.
When you will find issues, please report them with the `NEXT` word at the start of the issue title.

@@ -188,2 +187,3 @@ [issues](https://github.com/capacitor-community/sqlite/issues)

### API
[API_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/API.md)

@@ -199,8 +199,6 @@

### Framework's Usage
[Ionic/Angular_Usage_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md)
[Ionic/React_Usage_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-React-Usage.md)
[Ionic/Vue_Usage_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Vue-Usage.md)
## Applications demonstrating the use of the plugin

@@ -212,10 +210,6 @@

### Ionic/React
### Ionic/React (to come later)
- [react-sqlite-app-refactor](https://github.com/jepiqueau/react-sqlite-app-starter/tree/refactor)
### Ionic/Vue (to come later)
### Ionic/Vue
- [vue-sqlite-app-refactor](https://github.com/jepiqueau/vue-sqlite-app-starter/tree/refactor)
### Vue (to come later)

@@ -229,6 +223,3 @@

- [In your Ionic/React App](https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-React-Usage.md)
- [In your Ionic/Vue App](https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Vue-Usage.md)
## Dependencies

@@ -235,0 +226,0 @@ 

android/.classpath
android/.gradle/5.6.4/executionHistory/executionHistory.lock
android/.gradle/5.6.4/fileChanges/last-build.bin
android/.gradle/5.6.4/fileHashes/fileHashes.lock
android/.gradle/5.6.4/gc.properties
android/.gradle/buildOutputCleanup/buildOutputCleanup.lock
android/.gradle/buildOutputCleanup/cache.properties
android/.gradle/buildOutputCleanup/outputFiles.bin
android/.gradle/vcs-1/gc.properties
android/.idea/caches/build_file_checksums.ser
android/.idea/codeStyles/Project.xml
android/.idea/gradle.xml
android/.idea/libraries/Gradle__androidx_coordinatorlayout_coordinatorlayout_1_1_0_aar.xml
android/.idea/libraries/Gradle__androidx_customview_customview_1_0_0_aar.xml
android/.idea/libraries/Gradle__androidx_sqlite_sqlite_2_0_1_aar.xml
android/.idea/libraries/Gradle__androidx_test_core_1_2_0_aar.xml
android/.idea/libraries/Gradle__androidx_test_ext_junit_1_1_1_aar.xml
android/.idea/libraries/Gradle__androidx_test_monitor_1_2_0_aar.xml
android/.idea/libraries/Gradle__androidx_versionedparcelable_versionedparcelable_1_1_0_aar.xml
android/.idea/misc.xml
android/.idea/vcs.xml
android/.idea/workspace.xml
android/.npmignore
android/.project
android/.settings/org.eclipse.buildship.core.prefs
android/gradle.properties
android/gradle/wrapper/gradle-wrapper.jar
android/gradle/wrapper/gradle-wrapper.properties
android/gradlew
android/gradlew.bat
android/local.properties
android/proguard-rules.pro
android/settings.gradle
android/src/androidTest/java/com/getcapacitor/android/ExampleInstrumentedTest.java
android/src/main/res/layout/bridge_layout_main.xml
android/src/main/res/values/colors.xml
android/src/main/res/values/strings.xml
android/src/main/res/values/styles.xml
android/src/test/java/com/getcapacitor/ExampleUnitTest.java
ios/.npmignore
ios/Plugin.xcodeproj/project.pbxproj
ios/Plugin.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
ios/Plugin/Plugin.h
ios/Plugin/Plugin.m
ios/Plugin/Plugin.swift
ios/PluginTests/Info.plist
ios/PluginTests/PluginTests.swift
ios/Podfile
android/build.gradle

Sorry, the diff of this file is not supported yet

android/src/main/AndroidManifest.xml

Sorry, the diff of this file is not supported yet

android/src/main/java/com/getcapacitor/community/database/sqlite/CapacitorSQLite.java

Sorry, the diff of this file is not supported yet

android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/Database.java

Sorry, the diff of this file is not supported yet

android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/ImportExportJson/ExportToJson.java

Sorry, the diff of this file is not supported yet

android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/ImportExportJson/ImportFromJson.java

Sorry, the diff of this file is not supported yet

android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/ImportExportJson/UtilsJson.java

Sorry, the diff of this file is not supported yet

android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/UtilsDrop.java

Sorry, the diff of this file is not supported yet

CapacitorCommunitySqlite.podspec

Sorry, the diff of this file is not supported yet

dist/esm/definitions.js.map

Sorry, the diff of this file is not supported yet

dist/esm/index.js.map

Sorry, the diff of this file is not supported yet

dist/esm/web.js.map

Sorry, the diff of this file is not supported yet

dist/plugin.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/Database.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/ImportExportJson/exportToJson.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/ImportExportJson/importFromJson.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/ImportExportJson/utilsJson.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/utilsDrop.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/utilsEncryption.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/utilsFile.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/utilsSQLite.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/electron-utils/utilsUpgrade.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/GlobalSQLite.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/electron/src/plugin.js.map

Sorry, the diff of this file is not supported yet

electron/dist/esm/src/definitions.js.map

Sorry, the diff of this file is not supported yet

electron/dist/plugin.js

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

electron/dist/plugin.js.map

Sorry, the diff of this file is not supported yet

ios/Plugin/Database.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/GlobalSQLite.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/ImportExportJson/ExportToJson.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/ImportExportJson/ImportFromJson.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/ImportExportJson/JsonSQLite.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/ReturnHandler.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsBinding.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsDrop.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsEncryption.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsFile.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsJson.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsSQLCipher.swift

Sorry, the diff of this file is not supported yet

ios/Plugin/Utils/UtilsUpgrade.swift

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