jeep-sqlite - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

dist/cjs/jeep-sqlite.cjs.js

 'use strict';
 
-const index = require('./index-6648cacc.js');
+const index = require('./index-01333270.js');
 
@@ -18,3 +18,3 @@ /*
 patchBrowser().then(options => {
-  return index.bootstrapLazy([["jeep-sqlite.cjs",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64]}]]]], options);
+  return index.bootstrapLazy([["jeep-sqlite.cjs",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64],"isDatabase":[64],"getDatabaseList":[64],"checkConnectionsConsistency":[64]}]]]], options);
 });

dist/cjs/loader.cjs.js

@@ -5,3 +5,3 @@ 'use strict';
 
-const index = require('./index-6648cacc.js');
+const index = require('./index-01333270.js');
 
@@ -18,3 +18,3 @@ /*
   return patchEsm().then(() => {
-  return index.bootstrapLazy([["jeep-sqlite.cjs",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64]}]]]], options);
+  return index.bootstrapLazy([["jeep-sqlite.cjs",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64],"isDatabase":[64],"getDatabaseList":[64],"checkConnectionsConsistency":[64]}]]]], options);
   });
@@ -21,0 +21,0 @@ };

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

@@ -1,6 +0,6 @@
-import { Component, Method } from '@stencil/core';
+import { Component, Method, Event } from '@stencil/core';
 import { Database } from '../../utils/database';
 import localForage from 'localforage';
 import { isJsonSQLite } from '../../utils/utils-json';
-import { saveDBToStore } from '../../utils/utils-store';
+import { saveDBToStore, isDBInStore, getDBListFromStore } from '../../utils/utils-store';
 export class JeepSqlite {
@@ -15,4 +15,4 @@ constructor() {
   //**********************
-  async echo(value) {
-    return { value: value };
+  async echo(options) {
+    return options;
   }
@@ -352,2 +352,39 @@ async createConnection(options) {
   }
+  async isDatabase(options) {
+    const keys = Object.keys(options);
+    if (!keys.includes('database')) {
+      return Promise.reject('Must provide a database name');
+    }
+    const dbName = options.database;
+    try {
+      const ret = await this._isDatabase(dbName);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async getDatabaseList() {
+    try {
+      const ret = await this._getDatabaseList();
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async checkConnectionsConsistency(options) {
+    const keys = Object.keys(options);
+    if (!keys.includes('dbNames')) {
+      return Promise.reject(`Must provide a list of connection's name`);
+    }
+    const dbNames = options.dbNames;
+    try {
+      const ret = await this._checkConnectionsConsistency(dbNames);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
   //*******************************
@@ -362,2 +399,3 @@ //* Component Lifecycle Methods *
   componentDidLoad() {
+    console.log(`StoreName: ${this.storeName}`);
   }
@@ -631,3 +669,3 @@ //******************************
       // Import the JsonSQLite Object
-      const changes = await mDb.importJson(vJsonObj);
+      const changes = await mDb.importJson(vJsonObj, this.importProgress);
       // Close the database
@@ -648,3 +686,3 @@ await mDb.close();
     try {
-      const ret = await mDb.exportJson(exportMode);
+      const ret = await mDb.exportJson(exportMode, this.exportProgress);
       const keys = Object.keys(ret);
@@ -673,2 +711,86 @@ if (keys.includes('message')) {
   }
+  async _isDatabase(database) {
+    try {
+      const ret = await isDBInStore(database + 'SQLite.db', this.store);
+      const result = { result: ret };
+      return Promise.resolve(result);
+    }
+    catch (err) {
+      return Promise.reject(`IsDatabase: ${err.message}`);
+    }
+  }
+  async _getDatabaseList() {
+    try {
+      const ret = await getDBListFromStore(this.store);
+      const result = { values: ret };
+      return Promise.resolve(result);
+    }
+    catch (err) {
+      return Promise.reject(`GetDatabaseList: ${err.message}`);
+    }
+  }
+  async _checkConnectionsConsistency(dbNames) {
+    const ret = {};
+    ret.result = false;
+    try {
+      let inConnectionsSet = new Set(Object.keys(this._dbDict));
+      const outConnectionSet = new Set(dbNames);
+      if (outConnectionSet.size === 0) {
+        await this._resetDbDict(Object.keys(this._dbDict));
+        return Promise.resolve(ret);
+      }
+      if (inConnectionsSet.size < outConnectionSet.size) {
+        await this._resetDbDict(Object.keys(this._dbDict));
+        return Promise.resolve(ret);
+      }
+      if (inConnectionsSet.size > outConnectionSet.size) {
+        for (const key of inConnectionsSet) {
+          if (!Array.from(outConnectionSet.keys()).includes(key)) {
+            await this._closeConnection(key);
+          }
+        }
+      }
+      inConnectionsSet = new Set(Object.keys(this._dbDict));
+      if (inConnectionsSet.size === outConnectionSet.size) {
+        const symDiffSet = await this.symmetricDifference(inConnectionsSet, outConnectionSet);
+        if (symDiffSet.size === 0) {
+          ret.result = true;
+          return Promise.resolve(ret);
+        }
+        else {
+          await this._resetDbDict(Object.keys(this._dbDict));
+          return Promise.resolve(ret);
+        }
+      }
+      else {
+        await this._resetDbDict(Object.keys(this._dbDict));
+        return Promise.resolve(ret);
+      }
+    }
+    catch (err) {
+      return Promise.reject(`CheckConnectionsConsistency: ${err.message}`);
+    }
+  }
+  async _resetDbDict(keys) {
+    try {
+      for (const key of keys) {
+        await this._closeConnection(key);
+      }
+    }
+    catch (err) {
+      return Promise.reject(`ResetDbDict: ${err.message}`);
+    }
+  }
+  async symmetricDifference(setA, setB) {
+    let _difference = new Set(setA);
+    for (const elem of setB) {
+      if (_difference.has(elem)) {
+        _difference.delete(elem);
+      }
+      else {
+        _difference.add(elem);
+      }
+    }
+    return _difference;
+  }
   async copyDatabase(dbAssetName) {
@@ -717,3 +839,2 @@ return new Promise((resolve, reject) => {
       this.storeName = dbName;
-      console.log(`this.storeName ${JSON.stringify(this.storeName)}`);
       ret = true;
@@ -757,6 +878,47 @@ }
   static get assetsDirs() { return ["assets"]; }
+  static get events() { return [{
+      "method": "importProgress",
+      "name": "jeepSqliteImportProgress",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "JsonProgressListener",
+        "resolved": "JsonProgressListener",
+        "references": {
+          "JsonProgressListener": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        }
+      }
+    }, {
+      "method": "exportProgress",
+      "name": "jeepSqliteExportProgress",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "JsonProgressListener",
+        "resolved": "JsonProgressListener",
+        "references": {
+          "JsonProgressListener": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        }
+      }
+    }]; }
   static get methods() { return {
     "echo": {
       "complexType": {
-        "signature": "(value: string) => Promise<EchoResult>",
+        "signature": "(options: EchoOptions) => Promise<EchoResult>",
         "parameters": [{
@@ -773,2 +935,6 @@ "tags": [],
             "path": "../../interfaces/interfaces"
+          },
+          "EchoOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
           }
@@ -1310,4 +1476,78 @@ },
       }
+    },
+    "isDatabase": {
+      "complexType": {
+        "signature": "(options: SQLiteOptions) => Promise<SQLiteResult>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteResult": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteResult>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getDatabaseList": {
+      "complexType": {
+        "signature": "() => Promise<SQLiteValues>",
+        "parameters": [],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteValues": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteValues>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "checkConnectionsConsistency": {
+      "complexType": {
+        "signature": "(options: AllConnectionsOptions) => Promise<SQLiteResult>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteResult": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "AllConnectionsOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteResult>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
     }
   }; }
 }

dist/collection/utils/database.js

@@ -317,3 +317,3 @@ import initSqlJs from 'sql.js';
   }
-  async importJson(jsonData) {
+  async importJson(jsonData, importProgress) {
     let changes = -1;
@@ -324,5 +324,9 @@ if (this._isDBOpen) {
         changes = await createDatabaseSchema(this.mDb, jsonData);
+        let msg = `Schema creation completed changes: ${changes}`;
+        importProgress.emit({ progress: msg });
         if (changes != -1) {
           // create the tables data
-          changes = await createTablesData(this.mDb, jsonData);
+          changes = await createTablesData(this.mDb, jsonData, importProgress);
+          let msg = `Tables data creation completed changes: ${changes}`;
+          importProgress.emit({ progress: msg });
         }
@@ -339,3 +343,3 @@ return Promise.resolve(changes);
   }
-  async exportJson(mode) {
+  async exportJson(mode, exportProgress) {
     const inJson = {};
@@ -348,3 +352,3 @@ inJson.database = this.dbName.slice(0, -9);
       try {
-        const retJson = await createExportObject(this.mDb, inJson);
+        const retJson = await createExportObject(this.mDb, inJson, exportProgress);
         const isValid = isJsonSQLite(retJson);
@@ -351,0 +355,0 @@ if (isValid) {

dist/collection/utils/utils-drop.js

@@ -6,3 +6,4 @@ import { queryAll, run, execute } from './utils-sqlite';
   sql += "AND name NOT LIKE '_temp_%' ";
-  sql += "AND name NOT LIKE 'sqlite_%';";
+  sql += "AND name NOT LIKE 'sqlite_%' ";
+  sql += "ORDER BY rootpage DESC;";
   const retArr = [];
@@ -9,0 +10,0 @@ try {

dist/collection/utils/utils-exportJson.js

 import { queryAll } from './utils-sqlite';
 import { checkSchemaValidity, checkIndexesValidity, checkTriggersValidity, getTableColumnNamesTypes } from './utils-json';
-export const createExportObject = async (db, sqlObj) => {
+export const createExportObject = async (db, sqlObj, exportProgress) => {
   const retObj = {};
@@ -16,7 +16,7 @@ let tables = [];
         case 'partial': {
-          tables = await getTablesPartial(db, resTables);
+          tables = await getTablesPartial(db, resTables, exportProgress);
           break;
         }
         case 'full': {
-          tables = await getTablesFull(db, resTables);
+          tables = await getTablesFull(db, resTables, exportProgress);
           break;
@@ -60,3 +60,3 @@ }
 };
-export const getTablesFull = async (db, resTables) => {
+export const getTablesFull = async (db, resTables, exportProgress) => {
   const tables = [];
@@ -85,3 +85,3 @@ let errmsg = '';
       // create Table's Schema
-      const schema = await getSchema(sqlStmt, tableName);
+      const schema = await getSchema(sqlStmt /*, tableName*/);
       if (schema.length === 0) {
@@ -105,2 +105,4 @@ errmsg = 'GetTablesFull: no Schema returned';
       }
+      let msg = `Full: Table ${tableName} schema export completed ...`;
+      exportProgress.emit({ progress: msg });
       // create Table's Data
@@ -130,2 +132,4 @@ const query = `SELECT * FROM ${tableName};`;
       }
+      msg = `Full: Table ${tableName} table data export completed ...`;
+      exportProgress.emit({ progress: msg });
       tables.push(table);
@@ -142,3 +146,3 @@ }
 };
-export const getSchema = (sqlStmt, tableName) => {
+export const getSchema = async (sqlStmt /*, tableName: string*/) => {
   const schema = [];
@@ -148,48 +152,42 @@ // take the substring between parenthesis
   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 = [];
+  let sstr = sqlStmt.substring(openPar + 1, closePar);
+  // check if there is other parenthesis and replace the ',' by '§'
+  try {
+    sstr = await modEmbeddedParentheses(sstr);
+    const sch = sstr.split(",");
+    // for each element of the array split the
+    // first word as key
     for (let j = 0; j < sch.length; j++) {
-      if (sch[j].includes('strftime')) {
-        nSch.push(sch[j] + ',' + sch[j + 1]);
-        j++;
+      let row = [];
+      const scht = sch[j].trim();
+      row[0] = scht.substring(0, scht.indexOf(" "));
+      row[1] = scht.substring(scht.indexOf(" ") + 1);
+      const jsonRow = {};
+      if (row[0].toUpperCase() === "FOREIGN") {
+        const oPar = sch[j].indexOf("(");
+        const cPar = sch[j].indexOf(")");
+        row[0] = sch[j].substring(oPar + 1, cPar);
+        row[1] = sch[j].substring(cPar + 2);
+        jsonRow['foreignkey'] = row[0];
       }
+      else if (row[0].toUpperCase() === "CONSTRAINT") {
+        let tRow = [];
+        const row1t = row[1].trim();
+        tRow[0] = row1t.substring(0, row1t.indexOf(" "));
+        tRow[1] = row1t.substring(row1t.indexOf(" ") + 1);
+        row[0] = tRow[0];
+        jsonRow['constraint'] = row[0];
+        row[1] = tRow[1];
+      }
       else {
-        nSch.push(sch[j]);
+        jsonRow['column'] = row[0];
       }
+      jsonRow['value'] = row[1].replace(/§/g, ",");
+      schema.push(jsonRow);
     }
-    sch = [...nSch];
+    return Promise.resolve(schema);
   }
-  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) {
-        errmsg = `GetSchema: table ${tableName} row length != 2`;
-        break;
-      }
-      schema.push({ foreignkey: row[0], value: row[1] });
-    }
+  catch (err) {
+    return Promise.reject(new Error(err.message));
   }
-  if (errmsg.length > 0) {
-    return Promise.reject(new Error(errmsg));
-  }
-  return Promise.resolve(schema);
 };
@@ -333,3 +331,3 @@ export const getIndexes = async (db, tableName) => {
 };
-export const getTablesPartial = async (db, resTables) => {
+export const getTablesPartial = async (db, resTables, exportProgress) => {
   const tables = [];
@@ -380,3 +378,3 @@ let modTables = {};
         // create Table's Schema
-        schema = await getSchema(sqlStmt, tableName);
+        schema = await getSchema(sqlStmt /*, tableName*/);
         if (schema.length > 0) {
@@ -399,2 +397,4 @@ // check schema validity
       }
+      let msg = `Partial: Table ${tableName} schema export completed ...`;
+      exportProgress.emit({ progress: msg });
       // create Table's Data
@@ -429,2 +429,4 @@ let query = '';
       }
+      msg = `Partial: Table ${tableName} table data export completed ...`;
+      exportProgress.emit({ progress: msg });
       tables.push(table);
@@ -518,1 +520,39 @@ }
 };
+const modEmbeddedParentheses = async (sstr) => {
+  const oParArray = indexOfChar(sstr, '(');
+  const cParArray = indexOfChar(sstr, ')');
+  if (oParArray.length != cParArray.length) {
+    return Promise.reject("ModEmbeddedParentheses: Not same number of '(' & ')'");
+  }
+  if (oParArray.length === 0) {
+    return Promise.resolve(sstr);
+  }
+  let resStmt = sstr.substring(0, oParArray[0] - 1);
+  for (let i = 0; i < oParArray.length; i++) {
+    let str;
+    if (i < oParArray.length - 1) {
+      if (oParArray[i + 1] < cParArray[i]) {
+        str = sstr.substring(oParArray[i] - 1, cParArray[i + 1]);
+        i++;
+      }
+      else {
+        str = sstr.substring(oParArray[i] - 1, cParArray[i]);
+      }
+    }
+    else {
+      str = sstr.substring(oParArray[i] - 1, cParArray[i]);
+    }
+    const newS = str.replace(/,/g, "§");
+    resStmt += newS;
+    if (i < oParArray.length - 1) {
+      resStmt += sstr.substring(cParArray[i], oParArray[i + 1] - 1);
+    }
+  }
+  resStmt += sstr.substring(cParArray[cParArray.length - 1], sstr.length);
+  return Promise.resolve(resStmt);
+};
+const indexOfChar = (str, char) => {
+  let tmpArr = [...str];
+  char = char.toLowerCase();
+  return tmpArr.reduce((results, elem, idx) => elem.toLowerCase() === char ? [...results, idx] : results, []);
+};

dist/collection/utils/utils-importJson.js

@@ -32,3 +32,3 @@ import { setForeignKeyConstraintsEnabled, setVersion, beginTransaction, rollbackTransaction, commitTransaction, execute, dbChanges, run, queryAll, isTableExists } from './utils-sqlite';
   catch (err) {
-    return Promise.reject(new Error(`CreateDatabaseSchema: ${err.message}`));
+    return Promise.reject(new Error(`CreateSchema: ${err.message}`));
   }
@@ -124,4 +124,7 @@ const stmts = await createSchemaStatement(jsonData);
           const tableName = jTable.name;
+          if (jTrg.timeevent.toUpperCase().endsWith(" ON")) {
+            jTrg.timeevent = jTrg.timeevent.substring(0, jTrg.timeevent.length - 3);
+          }
           let stmt = `CREATE TRIGGER IF NOT EXISTS `;
-          stmt += `${jTrg.name} ${jTrg.timeevent} ${tableName} `;
+          stmt += `${jTrg.name} ${jTrg.timeevent} ON ${tableName} `;
           if (jTrg.condition)
@@ -140,3 +143,3 @@ stmt += `${jTrg.condition} `;
 };
-export const createTablesData = async (db, jsonData) => {
+export const createTablesData = async (db, jsonData, importProgress) => {
   let changes = 0;
@@ -160,2 +163,4 @@ let isValue = false;
         lastId = await createDataTable(db, jTable, jsonData.mode);
+        const msg = `create table data ${jTable.name}`;
+        importProgress.emit({ progress: msg });
         if (lastId < 0)
@@ -215,7 +220,8 @@ break;
       // Check the column's type before proceeding
-      const isColumnTypes = await checkColumnTypes(tableColumnTypes, table.values[j]);
-      if (!isColumnTypes) {
-        return Promise.reject(new Error(`CreateDataTable: Table ${table.name} ` +
-          `values row ${j} not correct types`));
-      }
+      // remove type checking for allowing RDBMS Types
+      /*await checkColumnTypes(
+        tableColumnTypes,
+        table.values[j],
+      );
+      */
       const retisIdExists = await isIdExists(db, table.name, tableColumnNames[0], table.values[j][0]);
@@ -297,5 +303,4 @@ let stmt;
 export const checkColumnTypes = async (tableTypes, rowValues) => {
-  const isTypeCorrect = true;
   for (let i = 0; i < rowValues.length; i++) {
-    if (rowValues[i].toString().toUpperCase() != 'NULL') {
+    if (rowValues[i] != null) {
       try {
@@ -309,3 +314,3 @@ await isType(tableTypes[i], rowValues[i]);
   }
-  return Promise.resolve(isTypeCorrect);
+  return Promise.resolve();
 };
@@ -312,0 +317,0 @@ export const createQuestionMarkString = async (length) => {

dist/collection/utils/utils-store.js

@@ -109,1 +109,10 @@ export const getDBFromStore = async (dbName, store) => {
 };
+export const getDBListFromStore = async (store) => {
+  try {
+    const retDbList = await store.keys();
+    return Promise.resolve(retDbList);
+  }
+  catch (err) {
+    return Promise.reject(`GetDBListFromStore: ${err.message}`);
+  }
+};

dist/esm/jeep-sqlite.js

@@ -1,2 +0,2 @@
-import { p as promiseResolve, b as bootstrapLazy } from './index-44bbc037.js';
+import { p as promiseResolve, b as bootstrapLazy } from './index-74b93e25.js';
 
@@ -16,3 +16,3 @@ /*
 patchBrowser().then(options => {
-  return bootstrapLazy([["jeep-sqlite",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64]}]]]], options);
+  return bootstrapLazy([["jeep-sqlite",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64],"isDatabase":[64],"getDatabaseList":[64],"checkConnectionsConsistency":[64]}]]]], options);
 });

dist/esm/loader.js

@@ -1,2 +0,2 @@
-import { p as promiseResolve, b as bootstrapLazy } from './index-44bbc037.js';
+import { p as promiseResolve, b as bootstrapLazy } from './index-74b93e25.js';
 
@@ -13,3 +13,3 @@ /*
   return patchEsm().then(() => {
-  return bootstrapLazy([["jeep-sqlite",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64]}]]]], options);
+  return bootstrapLazy([["jeep-sqlite",[[1,"jeep-sqlite",{"echo":[64],"createConnection":[64],"closeConnection":[64],"open":[64],"close":[64],"execute":[64],"executeSet":[64],"run":[64],"query":[64],"isDBExists":[64],"isDBOpen":[64],"deleteDatabase":[64],"isStoreOpen":[64],"copyFromAssets":[64],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64],"addUpgradeStatement":[64],"isDatabase":[64],"getDatabaseList":[64],"checkConnectionsConsistency":[64]}]]]], options);
   });
@@ -16,0 +16,0 @@ };

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

@@ -1,1 +0,1 @@
-import{p as e,b as t}from"./p-0238e775.js";(()=>{const t=import.meta.url,s={};return""!==t&&(s.resourcesUrl=new URL(".",t).href),e(s)})().then((e=>t([["p-2d0ca263",[[1,"jeep-sqlite",{echo:[64],createConnection:[64],closeConnection:[64],open:[64],close:[64],execute:[64],executeSet:[64],run:[64],query:[64],isDBExists:[64],isDBOpen:[64],deleteDatabase:[64],isStoreOpen:[64],copyFromAssets:[64],isTableExists:[64],createSyncTable:[64],getSyncDate:[64],setSyncDate:[64],isJsonValid:[64],importFromJson:[64],exportToJson:[64],addUpgradeStatement:[64]}]]]],e)));
+import{p as e,b as t}from"./p-9e937031.js";(()=>{const t=import.meta.url,s={};return""!==t&&(s.resourcesUrl=new URL(".",t).href),e(s)})().then((e=>t([["p-c5cbe85f",[[1,"jeep-sqlite",{echo:[64],createConnection:[64],closeConnection:[64],open:[64],close:[64],execute:[64],executeSet:[64],run:[64],query:[64],isDBExists:[64],isDBOpen:[64],deleteDatabase:[64],isStoreOpen:[64],copyFromAssets:[64],isTableExists:[64],createSyncTable:[64],getSyncDate:[64],setSyncDate:[64],isJsonValid:[64],importFromJson:[64],exportToJson:[64],addUpgradeStatement:[64],isDatabase:[64],getDatabaseList:[64],checkConnectionsConsistency:[64]}]]]],e)));

dist/types/components.d.ts

@@ -8,6 +8,7 @@ /* eslint-disable */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
-import { ConnectionOptions, EchoResult, SQLiteChanges, SQLiteExecuteOptions, SQLiteExportOptions, SQLiteImportOptions, SQLiteJson, SQLiteOptions, SQLiteQueryOptions, SQLiteResult, SQLiteRunOptions, SQLiteSet, SQLiteSetOptions, SQLiteSyncDate, SQLiteSyncDateOptions, SQLiteTableOptions, SQLiteUpgradeOptions, SQLiteValues, SQLiteVersionUpgrade } from "./interfaces/interfaces";
+import { AllConnectionsOptions, ConnectionOptions, EchoOptions, EchoResult, JsonProgressListener, SQLiteChanges, SQLiteExecuteOptions, SQLiteExportOptions, SQLiteImportOptions, SQLiteJson, SQLiteOptions, SQLiteQueryOptions, SQLiteResult, SQLiteRunOptions, SQLiteSet, SQLiteSetOptions, SQLiteSyncDate, SQLiteSyncDateOptions, SQLiteTableOptions, SQLiteUpgradeOptions, SQLiteValues, SQLiteVersionUpgrade } from "./interfaces/interfaces";
 export namespace Components {
     interface JeepSqlite {
         "addUpgradeStatement": (options: SQLiteUpgradeOptions) => Promise<void>;
+        "checkConnectionsConsistency": (options: AllConnectionsOptions) => Promise<SQLiteResult>;
         "close": (options: SQLiteOptions) => Promise<void>;
@@ -19,6 +20,7 @@ "closeConnection": (options: SQLiteOptions) => Promise<void>;
         "deleteDatabase": (options: SQLiteOptions) => Promise<void>;
-        "echo": (value: string) => Promise<EchoResult>;
+        "echo": (options: EchoOptions) => Promise<EchoResult>;
         "execute": (options: SQLiteExecuteOptions) => Promise<SQLiteChanges>;
         "executeSet": (options: SQLiteSetOptions) => Promise<SQLiteChanges>;
         "exportToJson": (options: SQLiteExportOptions) => Promise<SQLiteJson>;
+        "getDatabaseList": () => Promise<SQLiteValues>;
         "getSyncDate": (options: SQLiteSyncDateOptions) => Promise<SQLiteSyncDate>;
@@ -28,2 +30,3 @@ "importFromJson": (options: SQLiteImportOptions) => Promise<SQLiteChanges>;
         "isDBOpen": (options: SQLiteOptions) => Promise<SQLiteResult>;
+        "isDatabase": (options: SQLiteOptions) => Promise<SQLiteResult>;
         "isJsonValid": (options: SQLiteImportOptions) => Promise<SQLiteResult>;
@@ -51,2 +54,4 @@ "isStoreOpen": () => Promise<boolean>;
     interface JeepSqlite {
+        "onJeepSqliteExportProgress"?: (event: CustomEvent<JsonProgressListener>) => void;
+        "onJeepSqliteImportProgress"?: (event: CustomEvent<JsonProgressListener>) => void;
     }
@@ -53,0 +58,0 @@ interface IntrinsicElements {

dist/types/components/jeep-sqlite/jeep-sqlite.d.ts

@@ -1,4 +0,7 @@
-import { ConnectionOptions, SQLiteOptions, SQLiteExecuteOptions, SQLiteQueryOptions, SQLiteRunOptions, SQLiteSetOptions, SQLiteTableOptions, SQLiteSyncDateOptions, SQLiteImportOptions, SQLiteExportOptions, SQLiteUpgradeOptions, EchoResult, SQLiteChanges, SQLiteResult, SQLiteValues, SQLiteSyncDate, SQLiteJson } from '../../interfaces/interfaces';
+import { EventEmitter } from '../../stencil-public-runtime';
+import { EchoOptions, ConnectionOptions, SQLiteOptions, SQLiteExecuteOptions, SQLiteQueryOptions, SQLiteRunOptions, SQLiteSetOptions, SQLiteTableOptions, SQLiteSyncDateOptions, SQLiteImportOptions, SQLiteExportOptions, SQLiteUpgradeOptions, AllConnectionsOptions, EchoResult, SQLiteChanges, SQLiteResult, SQLiteValues, SQLiteSyncDate, SQLiteJson, JsonProgressListener } from '../../interfaces/interfaces';
 export declare class JeepSqlite {
-  echo(value: string): Promise<EchoResult>;
+  importProgress: EventEmitter<JsonProgressListener>;
+  exportProgress: EventEmitter<JsonProgressListener>;
+  echo(options: EchoOptions): Promise<EchoResult>;
   createConnection(options: ConnectionOptions): Promise<void>;
@@ -25,2 +28,5 @@ closeConnection(options: SQLiteOptions): Promise<void>;
   addUpgradeStatement(options: SQLiteUpgradeOptions): Promise<void>;
+  isDatabase(options: SQLiteOptions): Promise<SQLiteResult>;
+  getDatabaseList(): Promise<SQLiteValues>;
+  checkConnectionsConsistency(options: AllConnectionsOptions): Promise<SQLiteResult>;
   private store;
@@ -53,2 +59,7 @@ private storeName;
   _copyFromAssets(): Promise<void>;
+  _isDatabase(database: string): Promise<SQLiteResult>;
+  _getDatabaseList(): Promise<SQLiteValues>;
+  _checkConnectionsConsistency(dbNames: string[]): Promise<SQLiteResult>;
+  private _resetDbDict;
+  private symmetricDifference;
   private copyDatabase;
@@ -55,0 +66,0 @@ private loadJSON;

dist/types/interfaces/interfaces.d.ts

@@ -325,1 +325,7 @@ export interface EchoOptions {
 }
+export interface JsonProgressListener {
+  /**
+   * Progress message
+   */
+  progress?: string;
+}

dist/types/utils/database.d.ts

@@ -1,2 +0,3 @@
-import { SQLiteSet, JsonSQLite, SQLiteVersionUpgrade } from '../interfaces/interfaces';
+import { EventEmitter } from '../stencil-public-runtime';
+import { SQLiteSet, JsonSQLite, SQLiteVersionUpgrade, JsonProgressListener } from '../interfaces/interfaces';
 export declare class Database {
@@ -23,4 +24,4 @@ private _isDBOpen;
   setSyncDate(syncDate: string): Promise<any>;
-  importJson(jsonData: JsonSQLite): Promise<any>;
-  exportJson(mode: string): Promise<any>;
+  importJson(jsonData: JsonSQLite, importProgress: EventEmitter<JsonProgressListener>): Promise<any>;
+  exportJson(mode: string, exportProgress: EventEmitter<JsonProgressListener>): Promise<any>;
 }

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

@@ -1,12 +0,13 @@
-import { JsonSQLite, JsonTable, JsonColumn, JsonIndex, JsonTrigger } from '../interfaces/interfaces';
-export declare const createExportObject: (db: any, sqlObj: JsonSQLite) => Promise<JsonSQLite>;
+import { EventEmitter } from '../stencil-public-runtime';
+import { JsonSQLite, JsonTable, JsonColumn, JsonIndex, JsonTrigger, JsonProgressListener } from '../interfaces/interfaces';
+export declare const createExportObject: (db: any, sqlObj: JsonSQLite, exportProgress: EventEmitter<JsonProgressListener>) => Promise<JsonSQLite>;
 export declare const getTablesNameSQL: (db: any) => Promise<any[]>;
-export declare const getTablesFull: (db: any, resTables: any[]) => Promise<JsonTable[]>;
-export declare const getSchema: (sqlStmt: string, tableName: string) => Promise<JsonColumn[]>;
+export declare const getTablesFull: (db: any, resTables: any[], exportProgress: EventEmitter<JsonProgressListener>) => Promise<JsonTable[]>;
+export declare const getSchema: (sqlStmt: string) => Promise<JsonColumn[]>;
 export declare const getIndexes: (db: any, tableName: string) => Promise<JsonIndex[]>;
 export declare const getTriggers: (db: any, tableName: string) => Promise<JsonTrigger[]>;
 export declare const getValues: (db: any, query: string, tableName: string) => Promise<any[]>;
-export declare const getTablesPartial: (db: any, resTables: any[]) => Promise<JsonTable[]>;
+export declare const getTablesPartial: (db: any, resTables: any[], exportProgress: EventEmitter<JsonProgressListener>) => Promise<JsonTable[]>;
 export declare const getPartialModeData: (db: any, resTables: any[]) => Promise<any>;
 export declare const getTablesModified: (db: any, tables: any[], syncDate: number) => Promise<any>;
 export declare const getSynchroDate: (db: any) => Promise<number>;

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

@@ -1,11 +0,12 @@
-import { JsonSQLite } from '../interfaces/interfaces';
+import { EventEmitter } from '../stencil-public-runtime';
+import { JsonSQLite, JsonProgressListener } from '../interfaces/interfaces';
 export declare const createDatabaseSchema: (db: any, jsonData: JsonSQLite) => Promise<number>;
 export declare const createSchema: (db: any, jsonData: any) => Promise<number>;
 export declare const createSchemaStatement: (jsonData: any) => Promise<string[]>;
-export declare const createTablesData: (db: any, jsonData: JsonSQLite) => Promise<number>;
+export declare const createTablesData: (db: any, jsonData: JsonSQLite, importProgress: EventEmitter<JsonProgressListener>) => Promise<number>;
 export declare const createDataTable: (db: any, table: any, mode: string) => Promise<number>;
 export declare const isIdExists: (db: any, dbName: string, firstColumnName: string, key: any) => Promise<boolean>;
 export declare const isType: (type: string, value: any) => Promise<void>;
-export declare const checkColumnTypes: (tableTypes: any[], rowValues: any[]) => Promise<boolean>;
+export declare const checkColumnTypes: (tableTypes: any[], rowValues: any[]) => Promise<void>;
 export declare const createQuestionMarkString: (length: number) => Promise<string>;
 export declare const setNameForUpdate: (names: string[]) => Promise<string>;

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

@@ -9,1 +9,2 @@ export declare const getDBFromStore: (dbName: string, store: LocalForage) => Promise<Uint8Array>;
 export declare const copyDBToStore: (dbName: string, toDb: string, store: LocalForage) => Promise<void>;
+export declare const getDBListFromStore: (store: LocalForage) => Promise<string[]>;

package.json

 {
   "name": "jeep-sqlite",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Browser SQLite Stencil Component",
@@ -5,0 +5,0 @@ "main": "dist/index.cjs.js",

readme.md

@@ -70,3 +70,7 @@ ![Built With Stencil](https://img.shields.io/badge/-Built%20With%20Stencil-16161d.svg?logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMSwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCA1MTIgNTEyIiBzdHlsZT0iZW5hYmxlLWJhY2tncm91bmQ6bmV3IDAgMCA1MTIgNTEyOyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSI%2BCjxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI%2BCgkuc3Qwe2ZpbGw6I0ZGRkZGRjt9Cjwvc3R5bGU%2BCjxwYXRoIGNsYXNzPSJzdDAiIGQ9Ik00MjQuNywzNzMuOWMwLDM3LjYtNTUuMSw2OC42LTkyLjcsNjguNkgxODAuNGMtMzcuOSwwLTkyLjctMzAuNy05Mi43LTY4LjZ2LTMuNmgzMzYuOVYzNzMuOXoiLz4KPHBhdGggY2xhc3M9InN0MCIgZD0iTTQyNC43LDI5Mi4xSDE4MC40Yy0zNy42LDAtOTIuNy0zMS05Mi43LTY4LjZ2LTMuNkgzMzJjMzcuNiwwLDkyLjcsMzEsOTIuNyw2OC42VjI5Mi4xeiIvPgo8cGF0aCBjbGFzcz0ic3QwIiBkPSJNNDI0LjcsMTQxLjdIODcuN3YtMy42YzAtMzcuNiw1NC44LTY4LjYsOTIuNy02OC42SDMzMmMzNy45LDAsOTIuNywzMC43LDkyLjcsNjguNlYxNDEuN3oiLz4KPC9zdmc%2BCg%3D%3D&colorA=16161d&style=flat-square)
 | addUpgradeStatement         | ✅      |
+| isDatabase                  | ✅      |
+| getDatabaseList             | ✅      |
+| checkConnectionsConsistency | ✅      |
 
+
 The database is saved when you run the methods `close`or `closeConnection`, in the Browser Storage `IndexedDB` as a `localforage` store under the `jeepSqliteStore` name and `databases`table name.
@@ -87,2 +91,11 @@
 
+## Supported Events
+
+| Name                        | Web     |
+| :-------------------------- | :------ |
+| jeepSqliteImportProgress    | ✅      |
+| jeepSqliteExportProgress    | ✅      |
+
+
+
 ## Usage
@@ -89,0 +102,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1481701

increased by2.19%

Lines of code

31514

increased by2.64%

Number of lines in readme file

671

increased by1.98%

No dependency changes