jeep-sqlite - npm Package Compare versions

Comparing version 0.0.1-alpha.4 to 0.0.1-beta.1

dist/cjs/jeep-sqlite.cjs.js

 'use strict';
 
-const index = require('./index-279a5fbf.js');
+const index = require('./index-e7997958.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]}]]]], options);
+  return index.bootstrapLazy([["jeep-sqlite.cjs",[[1,"jeep-sqlite",{"dbAssetName":[32],"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],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64]}]]]], options);
 });

dist/cjs/loader.cjs.js

@@ -5,3 +5,3 @@ 'use strict';
 
-const index = require('./index-279a5fbf.js');
+const index = require('./index-e7997958.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]}]]]], options);
+  return index.bootstrapLazy([["jeep-sqlite.cjs",[[1,"jeep-sqlite",{"dbAssetName":[32],"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],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64]}]]]], options);
   });
@@ -21,0 +21,0 @@ };

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

@@ -1,4 +0,6 @@
-import { Component, Method } from '@stencil/core';
+import { Component, Method, State, Element, /* h, getAssetPath*/ } from '@stencil/core';
 import { Database } from '../../utils/database';
 import localForage from 'localforage';
+//import { databaseList } from '../../assets/databases/databases.json';
+import { isJsonSQLite } from '../../utils/utils-json';
 export class JeepSqlite {
@@ -22,3 +24,2 @@ constructor() {
     const version = options.version ? options.version : 1;
-    console.log(`in createConnection database ${dbName}`);
     try {
@@ -185,3 +186,2 @@ await this._createConnection(dbName, version);
       const ret = await this._isDBOpen(dbName);
-      console.log(`in method isDBOpen ${ret}`);
       return Promise.resolve(ret);
@@ -209,2 +209,125 @@ }
   }
+  /*  @Method()
+    async copyFromAssets(): Promise<void> {
+      try {
+        await this._copyFromAssets();
+        return Promise.resolve();
+      }
+      catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  */
+  async isTableExists(options) {
+    const keys = Object.keys(options);
+    if (!keys.includes('database')) {
+      return Promise.reject('Must provide a database name');
+    }
+    const dbName = options.database;
+    if (!keys.includes('table')) {
+      return Promise.reject('Must provide a table name');
+    }
+    const tableName = options.table;
+    try {
+      const ret = await this._isTableExists(dbName, tableName);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async createSyncTable(options) {
+    let 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._createSyncTable(dbName);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async getSyncDate(options) {
+    let 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._getSyncDate(dbName);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async setSyncDate(options) {
+    let keys = Object.keys(options);
+    if (!keys.includes('database')) {
+      return Promise.reject('Must provide a database name');
+    }
+    if (!keys.includes('syncdate')) {
+      return Promise.reject('Must provide a synchronization date');
+    }
+    const dbName = options.database;
+    const syncDate = options.syncdate;
+    try {
+      await this._setSyncDate(dbName, syncDate);
+      return Promise.resolve();
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async isJsonValid(options) {
+    const keys = Object.keys(options);
+    if (!keys.includes('jsonstring')) {
+      return Promise.reject('Must provide a json object');
+    }
+    const jsonStrObj = options.jsonstring;
+    try {
+      const ret = await this._isJsonValid(jsonStrObj);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async importFromJson(options) {
+    const keys = Object.keys(options);
+    if (!keys.includes('jsonstring')) {
+      return Promise.reject('Must provide a json object');
+    }
+    const jsonStrObj = options.jsonstring;
+    try {
+      const ret = await this._importFromJson(jsonStrObj);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async exportToJson(options) {
+    const keys = Object.keys(options);
+    if (!keys.includes('database')) {
+      return Promise.reject('Must provide a database name');
+    }
+    if (!keys.includes('jsonexportmode')) {
+      return Promise.reject('Must provide a json export mode');
+    }
+    const dbName = options.database;
+    const exportMode = options.jsonexportmode;
+    try {
+      const ret = await this._exportToJson(dbName, exportMode);
+      return Promise.resolve(ret);
+    }
+    catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  //  private dbInputELM: HTMLInputElement;
+  //  private _element: any;
   //*******************************
@@ -215,4 +338,13 @@ //* Component Lifecycle Methods *
     this.isStore = await this.openStore("jeepSqliteStore", "databases");
-    console.log(`&&& isStore ${this.isStore}`);
+    /*    this._element = this.el.shadowRoot;
+        const pathJson = getAssetPath(`assets/database/databases.json`);
+        console.log(`##### pathJson  ${pathJson} #####`);
+    
+        const response = await fetch(`${pathJson}`);
+        console.log(`response ${JSON.stringify(databaseList)}`)
+    */
   }
+  componentDidLoad() {
+    //    this.dbInputELM = this._element.querySelector('#db-input');
+  }
   //******************************
@@ -222,3 +354,2 @@ //* Private Method Definitions *
   async _createConnection(database, version) {
-    console.log(`in _createConnection ${database}`);
     try {
@@ -372,3 +503,3 @@ const mDB = new Database(database + 'SQLite.db', version, this.store);
     try {
-      const ret = mDB.isDBOpen(database + 'SQLite.db');
+      const ret = await mDB.isDBOpen(database + 'SQLite.db');
       const result = { result: ret };
@@ -395,2 +526,129 @@ return Promise.resolve(result);
   }
+  /*
+    private async _copyFromAssets(): Promise<void> {
+      try {
+  
+        return Promise.resolve();
+      } catch (err) {
+        return Promise.reject(`DeleteDatabase: ${err.message}`);
+      }
+    }
+  */
+  async _isTableExists(database, table) {
+    const keys = Object.keys(this._dbDict);
+    if (!keys.includes(database)) {
+      return Promise.reject(`IsTableExists: No available connection for ${database}`);
+    }
+    const mDB = this._dbDict[database];
+    try {
+      const ret = await mDB.isTable(table);
+      const result = { result: ret };
+      return Promise.resolve(result);
+    }
+    catch (err) {
+      return Promise.reject(`IsTableExists: ${err.message}`);
+    }
+  }
+  async _createSyncTable(database) {
+    const keys = Object.keys(this._dbDict);
+    if (!keys.includes(database)) {
+      return Promise.reject('CreateSyncTable: No available connection for ' + `${database}`);
+    }
+    const mDB = this._dbDict[database];
+    try {
+      const ret = await mDB.createSyncTable();
+      return Promise.resolve({ changes: { changes: ret } });
+    }
+    catch (err) {
+      return Promise.reject(`CreateSyncTable: ${err.message}`);
+    }
+  }
+  async _getSyncDate(database) {
+    const keys = Object.keys(this._dbDict);
+    if (!keys.includes(database)) {
+      return Promise.reject('GetSyncDate: No available connection for ' + `${database}`);
+    }
+    const mDB = this._dbDict[database];
+    try {
+      const ret = await mDB.getSyncDate();
+      return Promise.resolve({ syncDate: ret });
+    }
+    catch (err) {
+      return Promise.reject(`GetSyncDate: ${err.message}`);
+    }
+  }
+  async _setSyncDate(database, syncDate) {
+    const keys = Object.keys(this._dbDict);
+    if (!keys.includes(database)) {
+      return Promise.reject('SetSyncDate: No available connection for ' + `${database}`);
+    }
+    const mDB = this._dbDict[database];
+    try {
+      const ret = await mDB.setSyncDate(syncDate);
+      if (ret.result) {
+        return Promise.resolve();
+      }
+      else {
+        return Promise.reject(`SetSyncDate: ${ret.message}`);
+      }
+    }
+    catch (err) {
+      return Promise.reject(`SetSyncDate: ${err.message}`);
+    }
+  }
+  async _isJsonValid(jsonStrObj) {
+    const jsonObj = JSON.parse(jsonStrObj);
+    const isValid = await isJsonSQLite(jsonObj);
+    if (!isValid) {
+      return Promise.reject('IsJsonValid: Stringify Json Object not Valid');
+    }
+    else {
+      return Promise.resolve({ result: true });
+    }
+  }
+  async _importFromJson(jsonStrObj) {
+    var _a;
+    const jsonObj = JSON.parse(jsonStrObj);
+    const isValid = await isJsonSQLite(jsonObj);
+    if (!isValid) {
+      return Promise.reject('ImportFromJson: Stringify Json Object not Valid');
+    }
+    const vJsonObj = jsonObj;
+    const dbName = `${vJsonObj.database}SQLite.db`;
+    const dbVersion = (_a = vJsonObj.version) !== null && _a !== void 0 ? _a : 1;
+    // Create the database
+    const mDb = new Database(dbName, dbVersion, this.store);
+    try {
+      // Open the database
+      await mDb.open();
+      // Import the JsonSQLite Object
+      const changes = await mDb.importJson(vJsonObj);
+      // Close the database
+      await mDb.close();
+      return Promise.resolve({ changes: { changes: changes } });
+    }
+    catch (err) {
+      return Promise.reject(`ImportFromJson: ${err.message}`);
+    }
+  }
+  async _exportToJson(database, exportMode) {
+    const keys = Object.keys(this._dbDict);
+    if (!keys.includes(database)) {
+      return Promise.reject('ExportToJson: No available connection for ' + `${database}`);
+    }
+    const mDb = this._dbDict[database];
+    try {
+      const ret = await mDb.exportJson(exportMode);
+      const keys = Object.keys(ret);
+      if (keys.includes('message')) {
+        return Promise.reject(`ExportToJson: ${ret.message}`);
+      }
+      else {
+        return Promise.resolve({ export: ret });
+      }
+    }
+    catch (err) {
+      return Promise.reject(`ExportToJson: ${err.message}`);
+    }
+  }
   async openStore(dbName, tableName) {
@@ -416,4 +674,17 @@ let ret = false;
   }
+  /*  handleChange(event) {
+      this.dbAssetName = event.target.value;
+      const f = this.dbInputELM.files[0];
+      const r = new FileReader();
+      r.onload = () => {
+        const Uints = new Uint8Array(r.result)
+      }
+      r.readAsArrayBuffer(f);
+    }
+  */
   render() {
-    return;
+    return; /*(
+      <input id="db-input" type="text" value={this.dbAssetName} onInput={(event) => this.handleChange(event)} />
+
+    );*/
   }
@@ -428,2 +699,6 @@ static get is() { return "jeep-sqlite"; }
   }; }
+  static get assetsDirs() { return ["assets"]; }
+  static get states() { return {
+    "dbAssetName": {}
+  }; }
   static get methods() { return {
@@ -749,4 +1024,190 @@ "echo": {
       }
+    },
+    "isTableExists": {
+      "complexType": {
+        "signature": "(options: SQLiteTableOptions) => Promise<SQLiteResult>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteResult": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteTableOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteResult>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "createSyncTable": {
+      "complexType": {
+        "signature": "(options: SQLiteOptions) => Promise<SQLiteChanges>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteChanges": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteChanges>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getSyncDate": {
+      "complexType": {
+        "signature": "(options: SQLiteSyncDateOptions) => Promise<SQLiteSyncDate>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteSyncDate": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteSyncDateOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteSyncDate>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "setSyncDate": {
+      "complexType": {
+        "signature": "(options: SQLiteSyncDateOptions) => Promise<void>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteSyncDateOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "isJsonValid": {
+      "complexType": {
+        "signature": "(options: SQLiteImportOptions) => Promise<SQLiteResult>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteResult": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteImportOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteResult>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "importFromJson": {
+      "complexType": {
+        "signature": "(options: SQLiteImportOptions) => Promise<SQLiteChanges>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteChanges": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteImportOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteChanges>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "exportToJson": {
+      "complexType": {
+        "signature": "(options: SQLiteExportOptions) => Promise<SQLiteJson>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "SQLiteJson": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          },
+          "SQLiteExportOptions": {
+            "location": "import",
+            "path": "../../interfaces/interfaces"
+          }
+        },
+        "return": "Promise<SQLiteJson>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
     }
   }; }
+  static get elementRef() { return "el"; }
 }

dist/collection/utils/database.js

 import initSqlJs from 'sql.js';
 import { getDBFromStore, setInitialDBToStore, setDBToStore, removeDBFromStore, isDBInStore } from './utils-store';
-import { dbChanges, beginTransaction, rollbackTransaction, commitTransaction, execute, executeSet, run, queryAll } from './utils-sqlite';
+import { dbChanges, beginTransaction, rollbackTransaction, commitTransaction, execute, executeSet, run, queryAll, isTableExists } from './utils-sqlite';
+import { createDatabaseSchema, createTablesData } from './utils-importJson';
+import { isJsonSQLite } from './utils-json';
+import { createExportObject, getSynchroDate } from './utils-exportJson';
 export class Database {
@@ -13,3 +16,2 @@ constructor(databaseName, version, store) {
   async open() {
-    console.log(`&&& in open database ${this.dbName} version ${this.version}`);
     try {
@@ -31,3 +33,2 @@ const SQL = await initSqlJs({
       this._isDBOpen = true;
-      console.log(`isDBOpen: ${this._isDBOpen}`);
       return Promise.resolve();
@@ -70,6 +71,4 @@ }
     try {
-      console.log(`in deleteDB ${database}`);
       // test if file exists
       const isExists = await this.isDBExists(database);
-      console.log(`in deleteDB ${database} ${isExists}`);
       if (isExists && !this._isDBOpen) {
@@ -83,3 +82,2 @@ // open the database
       if (isExists) {
-        console.log(`in deleteDB ${database} going to remove`);
         await removeDBFromStore(database, this.store);
@@ -128,3 +126,2 @@ }
     }
-    console.log(`in execSet set ${set} ${transaction}`);
     const retRes = { changes: -1, lastId: -1 };
@@ -208,2 +205,129 @@ let initChanges = -1;
   }
+  async isTable(tableName) {
+    if (!this._isDBOpen) {
+      let msg = `isTable: Database ${this.dbName} `;
+      msg += `not opened`;
+      return Promise.reject(new Error(msg));
+    }
+    try {
+      const retB = await isTableExists(this.mDb, tableName);
+      return Promise.resolve(retB);
+    }
+    catch (err) {
+      const msg = `IsTable: ${err.message}`;
+      return Promise.reject(new Error(msg));
+    }
+  }
+  async createSyncTable() {
+    if (!this._isDBOpen) {
+      let msg = `createSyncTable: Database ${this.dbName} `;
+      msg += `not opened`;
+      return Promise.reject(new Error(msg));
+    }
+    let changes = -1;
+    try {
+      const retB = await isTableExists(this.mDb, 'sync_table');
+      if (!retB) {
+        const date = Math.round(new Date().getTime() / 1000);
+        let stmts = `
+                        CREATE TABLE IF NOT EXISTS sync_table (
+                            id INTEGER PRIMARY KEY NOT NULL,
+                            sync_date INTEGER
+                            );`;
+        stmts += `INSERT INTO sync_table (sync_date) VALUES (
+                            "${date}");`;
+        changes = await execute(this.mDb, stmts);
+        return Promise.resolve(changes);
+      }
+      else {
+        return Promise.resolve(0);
+      }
+    }
+    catch (err) {
+      const msg = `CreateSyncTable: ${err.message}`;
+      return Promise.reject(new Error(msg));
+    }
+  }
+  async getSyncDate() {
+    if (!this._isDBOpen) {
+      let msg = `getSyncDate: Database ${this.dbName} `;
+      msg += `not opened`;
+      return Promise.reject(new Error(msg));
+    }
+    try {
+      const res = await getSynchroDate(this.mDb);
+      return Promise.resolve(res);
+    }
+    catch (err) {
+      const msg = `getSyncDate: ${err.message}`;
+      return Promise.reject(new Error(msg));
+    }
+  }
+  async setSyncDate(syncDate) {
+    if (!this._isDBOpen) {
+      let msg = `SetSyncDate: Database ${this.dbName} `;
+      msg += `not opened`;
+      return { result: false, message: msg };
+    }
+    try {
+      const sDate = Math.round(new Date(syncDate).getTime() / 1000);
+      let stmt = `UPDATE sync_table SET sync_date = `;
+      stmt += `${sDate} WHERE id = 1;`;
+      const changes = await execute(this.mDb, stmt);
+      if (changes < 0) {
+        return { result: false, message: 'setSyncDate failed' };
+      }
+      else {
+        return { result: true };
+      }
+    }
+    catch (err) {
+      return { result: false, message: `setSyncDate failed: ${err.message}` };
+    }
+  }
+  async importJson(jsonData) {
+    let changes = -1;
+    if (this._isDBOpen) {
+      try {
+        // create the database schema
+        changes = await createDatabaseSchema(this.mDb, jsonData);
+        if (changes != -1) {
+          // create the tables data
+          changes = await createTablesData(this.mDb, jsonData);
+        }
+        return Promise.resolve(changes);
+      }
+      catch (err) {
+        return Promise.reject(new Error(`ImportJson: ${err.message}`));
+      }
+    }
+    else {
+      return Promise.reject(new Error(`ImportJson: database is closed`));
+    }
+  }
+  async exportJson(mode) {
+    const inJson = {};
+    inJson.database = this.dbName.slice(0, -9);
+    inJson.version = this.version;
+    inJson.encrypted = false;
+    inJson.mode = mode;
+    if (this._isDBOpen) {
+      try {
+        const retJson = await createExportObject(this.mDb, inJson);
+        const isValid = isJsonSQLite(retJson);
+        if (isValid) {
+          return Promise.resolve(retJson);
+        }
+        else {
+          return Promise.reject(new Error(`ExportJson: retJson not valid`));
+        }
+      }
+      catch (err) {
+        return Promise.reject(new Error(`ExportJson: ${err.message}`));
+      }
+    }
+    else {
+      return Promise.reject(new Error(`ExportJson: database is closed`));
+    }
+  }
 }

dist/collection/utils/utils-sqlite.js

@@ -69,2 +69,35 @@ export const beginTransaction = async (db, isOpen) => {
 };
+export const setForeignKeyConstraintsEnabled = async (db, toggle) => {
+  let key = 'OFF';
+  if (toggle) {
+    key = 'ON';
+  }
+  try {
+    await db.exec(`PRAGMA foreign_keys = '${key}'`);
+    return Promise.resolve();
+  }
+  catch (err) {
+    return Promise.reject(new Error(`SetForeignKey: ${err.message}`));
+  }
+};
+export const getVersion = async (db) => {
+  let version = 0;
+  try {
+    const res = await db.exec('PRAGMA user_version;');
+    version = res[0].values[0][0];
+    return Promise.resolve(version);
+  }
+  catch (err) {
+    return Promise.reject(new Error(`GetVersion: ${err.message}`));
+  }
+};
+export const setVersion = async (db, version) => {
+  try {
+    await db.exec(`PRAGMA user_version = ${version}`);
+    return Promise.resolve();
+  }
+  catch (err) {
+    return Promise.reject(new Error(`SetVersion: ${err.message}`));
+  }
+};
 export const execute = async (db, sql) => {
@@ -97,3 +130,2 @@ let changes = -1;
           const mVal = await replaceUndefinedByNull(val);
-          console.log(`in executeSet: i ${i} statement ${statement} val ${mVal}`);
           await db.exec(statement, mVal);
@@ -103,9 +135,6 @@ }
       else {
-        console.log(`in executeSet: i ${i} statement ${statement} values ${values}`);
         const mVal = await replaceUndefinedByNull(values);
-        const res = await db.exec(statement, mVal);
-        console.log(`in executeSet: ${JSON.stringify(res)}`);
+        await db.exec(statement, mVal);
       }
       lastId = await getLastId(db);
-      console.log(`in executeSet: i ${i} lastId ${lastId}`);
     }
@@ -128,2 +157,4 @@ catch (err) {
     }
+    if (retArr.length == 0)
+      return Promise.resolve([]);
     for (const valRow of retArr[0].values) {
@@ -159,2 +190,14 @@ const row = {};
 };
+export const isTableExists = async (db, tableName) => {
+  try {
+    let statement = 'SELECT name FROM sqlite_master WHERE ';
+    statement += `type='table' AND name='${tableName}';`;
+    const res = await queryAll(db, statement, []);
+    const ret = res.length > 0 ? true : false;
+    return Promise.resolve(ret);
+  }
+  catch (err) {
+    return Promise.reject(new Error(`isTableExists: ${err.message}`));
+  }
+};
 export const replaceUndefinedByNull = async (values) => {
@@ -161,0 +204,0 @@ const retValues = [];

dist/esm/jeep-sqlite.js

@@ -1,2 +0,2 @@
-import { p as promiseResolve, b as bootstrapLazy } from './index-f18cb60b.js';
+import { p as promiseResolve, b as bootstrapLazy } from './index-ae657c10.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]}]]]], options);
+  return bootstrapLazy([["jeep-sqlite",[[1,"jeep-sqlite",{"dbAssetName":[32],"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],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[64]}]]]], options);
 });

dist/esm/loader.js

@@ -1,2 +0,2 @@
-import { p as promiseResolve, b as bootstrapLazy } from './index-f18cb60b.js';
+import { p as promiseResolve, b as bootstrapLazy } from './index-ae657c10.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]}]]]], options);
+  return bootstrapLazy([["jeep-sqlite",[[1,"jeep-sqlite",{"dbAssetName":[32],"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],"isTableExists":[64],"createSyncTable":[64],"getSyncDate":[64],"setSyncDate":[64],"isJsonValid":[64],"importFromJson":[64],"exportToJson":[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-4002b696.js";(()=>{const t=import.meta.url,n={};return""!==t&&(n.resourcesUrl=new URL(".",t).href),e(n)})().then((e=>t([["p-33e10e09",[[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]}]]]],e)));
+import{p as e,b as t}from"./p-6cd6f78a.js";(()=>{const t=import.meta.url,s={};return""!==t&&(s.resourcesUrl=new URL(".",t).href),e(s)})().then((e=>t([["p-9ed906b9",[[1,"jeep-sqlite",{dbAssetName:[32],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],isTableExists:[64],createSyncTable:[64],getSyncDate:[64],setSyncDate:[64],isJsonValid:[64],importFromJson:[64],exportToJson:[64]}]]]],e)));

dist/types/components.d.ts

@@ -8,3 +8,3 @@ /* eslint-disable */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
-import { ConnectionOptions, EchoResult, SQLiteChanges, SQLiteExecuteOptions, SQLiteOptions, SQLiteQueryOptions, SQLiteResult, SQLiteRunOptions, SQLiteSet, SQLiteSetOptions, SQLiteValues } from "./interfaces/interfaces";
+import { ConnectionOptions, EchoResult, SQLiteChanges, SQLiteExecuteOptions, SQLiteExportOptions, SQLiteImportOptions, SQLiteJson, SQLiteOptions, SQLiteQueryOptions, SQLiteResult, SQLiteRunOptions, SQLiteSet, SQLiteSetOptions, SQLiteSyncDate, SQLiteSyncDateOptions, SQLiteTableOptions, SQLiteValues } from "./interfaces/interfaces";
 export namespace Components {
@@ -15,2 +15,3 @@ interface JeepSqlite {
         "createConnection": (options: ConnectionOptions) => Promise<void>;
+        "createSyncTable": (options: SQLiteOptions) => Promise<SQLiteChanges>;
         "deleteDatabase": (options: SQLiteOptions) => Promise<void>;
@@ -20,8 +21,14 @@ "echo": (value: string) => Promise<EchoResult>;
         "executeSet": (options: SQLiteSetOptions) => Promise<SQLiteChanges>;
+        "exportToJson": (options: SQLiteExportOptions) => Promise<SQLiteJson>;
+        "getSyncDate": (options: SQLiteSyncDateOptions) => Promise<SQLiteSyncDate>;
+        "importFromJson": (options: SQLiteImportOptions) => Promise<SQLiteChanges>;
         "isDBExists": (options: SQLiteOptions) => Promise<SQLiteResult>;
         "isDBOpen": (options: SQLiteOptions) => Promise<SQLiteResult>;
+        "isJsonValid": (options: SQLiteImportOptions) => Promise<SQLiteResult>;
         "isStoreOpen": () => Promise<boolean>;
+        "isTableExists": (options: SQLiteTableOptions) => Promise<SQLiteResult>;
         "open": (options: SQLiteOptions) => Promise<void>;
         "query": (options: SQLiteQueryOptions) => Promise<SQLiteValues>;
         "run": (options: SQLiteRunOptions) => Promise<SQLiteChanges>;
+        "setSyncDate": (options: SQLiteSyncDateOptions) => Promise<void>;
     }
@@ -28,0 +35,0 @@ }

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

@@ -1,3 +0,5 @@
-import { ConnectionOptions, SQLiteOptions, SQLiteExecuteOptions, SQLiteQueryOptions, SQLiteRunOptions, SQLiteSetOptions, EchoResult, SQLiteChanges, SQLiteResult, SQLiteValues } from '../../interfaces/interfaces';
+import { ConnectionOptions, SQLiteOptions, SQLiteExecuteOptions, SQLiteQueryOptions, SQLiteRunOptions, SQLiteSetOptions, SQLiteTableOptions, SQLiteSyncDateOptions, SQLiteImportOptions, SQLiteExportOptions, EchoResult, SQLiteChanges, SQLiteResult, SQLiteValues, SQLiteSyncDate, SQLiteJson } from '../../interfaces/interfaces';
 export declare class JeepSqlite {
+  el: HTMLJeepSqliteElement;
+  dbAssetName: string;
   echo(value: string): Promise<EchoResult>;
@@ -16,2 +18,9 @@ createConnection(options: ConnectionOptions): Promise<void>;
   isStoreOpen(): Promise<boolean>;
+  isTableExists(options: SQLiteTableOptions): Promise<SQLiteResult>;
+  createSyncTable(options: SQLiteOptions): Promise<SQLiteChanges>;
+  getSyncDate(options: SQLiteSyncDateOptions): Promise<SQLiteSyncDate>;
+  setSyncDate(options: SQLiteSyncDateOptions): Promise<void>;
+  isJsonValid(options: SQLiteImportOptions): Promise<SQLiteResult>;
+  importFromJson(options: SQLiteImportOptions): Promise<SQLiteChanges>;
+  exportToJson(options: SQLiteExportOptions): Promise<SQLiteJson>;
   private store;
@@ -22,2 +31,3 @@ private storeName;
   componentWillLoad(): Promise<void>;
+  componentDidLoad(): void;
   private _createConnection;
@@ -34,2 +44,9 @@ private _closeConnection;
   private _deleteDatabase;
+  private _isTableExists;
+  private _createSyncTable;
+  private _getSyncDate;
+  private _setSyncDate;
+  _isJsonValid(jsonStrObj: string): Promise<SQLiteResult>;
+  _importFromJson(jsonStrObj: string): Promise<SQLiteChanges>;
+  _exportToJson(database: string, exportMode: string): Promise<SQLiteJson>;
   private openStore;
@@ -36,0 +53,0 @@ private setConfig;

dist/types/interfaces/interfaces.d.ts

@@ -112,2 +112,42 @@ export interface EchoOptions {
 }
+export interface SQLiteTableOptions {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * The table name
+   */
+  table?: string;
+}
+export interface SQLiteSyncDateOptions {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * Set the synchronization date
+   * Format yyyy-MM-dd'T'HH:mm:ss.SSSZ
+   */
+  syncdate?: string;
+}
+export interface SQLiteImportOptions {
+  /**
+   * Set the JSON object to import
+   *
+   */
+  jsonstring?: string;
+}
+export interface SQLiteExportOptions {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * Set the mode to export JSON Object:
+   * "full" or "partial"
+   *
+   */
+  jsonexportmode?: string;
+}
 export interface SQLiteSet {
@@ -157,1 +197,113 @@ /**
 }
+export interface SQLiteSyncDate {
+  /**
+   * the synchronization date
+   */
+  syncDate?: number;
+}
+export interface SQLiteJson {
+  /**
+   * an export JSON object
+   */
+  export?: JsonSQLite;
+}
+export interface JsonSQLite {
+  /**
+   * The database name
+   */
+  database: string;
+  /**
+   *  The database version
+   */
+  version: number;
+  /**
+   * Set to true (database encryption) / false
+   */
+  encrypted: boolean;
+  /***
+   * Set the mode
+   * ["full", "partial"]
+   */
+  mode: string;
+  /***
+   * Array of Table (JsonTable)
+   */
+  tables: JsonTable[];
+}
+export interface JsonTable {
+  /**
+   * The database name
+   */
+  name: string;
+  /***
+   * Array of Schema (JsonColumn)
+   */
+  schema?: JsonColumn[];
+  /***
+   * Array of Index (JsonIndex)
+   */
+  indexes?: JsonIndex[];
+  /***
+   * Array of Trigger (JsonTrigger)
+   */
+  triggers?: JsonTrigger[];
+  /***
+   * Array of Table data
+   */
+  values?: any[][];
+}
+export interface JsonColumn {
+  /**
+   * The column name
+   */
+  column?: string;
+  /**
+   * The column data (type, unique, ...)
+   */
+  value: string;
+  /**
+   * The column foreign key constraints
+   */
+  foreignkey?: string;
+  /**
+   * the column constraint
+   */
+  constraint?: string;
+}
+export interface JsonTrigger {
+  /**
+   * The trigger name
+   */
+  name: string;
+  /**
+   * The trigger time event fired
+   */
+  timeevent: string;
+  /**
+   * The trigger condition
+   */
+  condition?: string;
+  /**
+   * The logic of the trigger
+   */
+  logic: string;
+}
+export interface JsonIndex {
+  /**
+   * The index name
+   */
+  name: string;
+  /**
+   * The value of the index can have the following formats:
+   * email
+   * email ASC
+   * email, MobileNumber
+   * email ASC, MobileNumber DESC
+   */
+  value: string;
+  /**
+   * the mode (Optional)
+   * UNIQUE
+   */
+  mode?: string;
+}

dist/types/utils/database.d.ts

@@ -1,2 +0,2 @@
-import { SQLiteSet } from '../interfaces/interfaces';
+import { SQLiteSet, JsonSQLite } from '../interfaces/interfaces';
 export declare class Database {
@@ -18,2 +18,8 @@ private _isDBOpen;
   runSQL(statement: string, values: any[], transaction?: boolean): Promise<any>;
+  isTable(tableName: string): Promise<boolean>;
+  createSyncTable(): Promise<number>;
+  getSyncDate(): Promise<number>;
+  setSyncDate(syncDate: string): Promise<any>;
+  importJson(jsonData: JsonSQLite): Promise<any>;
+  exportJson(mode: string): Promise<any>;
 }

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

@@ -6,2 +6,5 @@ export declare const beginTransaction: (db: any, isOpen: boolean) => Promise<void>;
 export declare const getLastId: (db: any) => Promise<number>;
+export declare const setForeignKeyConstraintsEnabled: (db: any, toggle: boolean) => Promise<void>;
+export declare const getVersion: (db: any) => Promise<number>;
+export declare const setVersion: (db: any, version: number) => Promise<void>;
 export declare const execute: (db: any, sql: string) => Promise<number>;
@@ -11,2 +14,3 @@ export declare const executeSet: (db: any, set: any) => Promise<number>;
 export declare const run: (db: any, statement: string, values: any[]) => Promise<number>;
+export declare const isTableExists: (db: any, tableName: string) => Promise<boolean>;
 export declare const replaceUndefinedByNull: (values: any[]) => Promise<any[]>;

package.json

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

readme.md

@@ -72,2 +72,9 @@ ![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)
 | isStoreOpen                 | ✅      |
+| isTableExists               | ✅      |
+| createSyncTable             | ✅      |
+| getSyncDate                 | ✅      |
+| setSyncDate                 | ✅      |
+| isJsonValid                 | ✅      |
+| importFromJson              | ✅      |
+| isJsonValid                 | ✅      |
 
@@ -74,0 +81,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

1366502

increased by20.67%

Number of package files

57

increased by16.33%

Lines of code

28936

increased by31.19%

Number of lines in readme file

239

increased by3.02%

No dependency changes