js/SimpleDB.js

  1. class BasicEventHandler {
  2.     constructor () {
  3.         const eventPooler = {};
  5.         const getNamespace = (str="")=> {
  6.             const sl = str.split(".");
  7.             var major = sl.shift();
  8.             return {
  9.                 "major": major,
  10.                 "minor": sl.join(".") || "*"
  11.             }
  12.         }
  14.         var id = 0;
  15.         const makeId = ()=> {
  16.             id++;
  17.             return id;
  18.         }
  20.         this.on = (eventName, fn)=> {
  21.             if (typeof fn !== "function") throw new error("Second parameter must be a function");
  22.             const nameSpace = getNamespace(eventName);
  23.             eventPooler[nameSpace.major] ||= {};
  24.             eventPooler[nameSpace.major][nameSpace.minor] ||= {};
  25.             eventPooler[nameSpace.major][nameSpace.minor][makeId()] = {
  26.                 fn:fn
  27.             };
  29.         }
  31.         this.one = (eventName, fn)=> {
  32.             if (typeof fn !== "function") throw new error("Second parameter must be a function")
  33.             const nameSpace = getNamespace(eventName);
  34.             eventPooler[nameSpace.major] ||= {};
  35.             eventPooler[nameSpace.major][nameSpace.minor] ||= {};
  36.             eventPooler[nameSpace.major][nameSpace.minor][makeId()] = {
  37.                 fn:fn,
  38.                 one:true
  39.             };
  40.         }
  42.         this.off = (eventName)=> {
  43.             if (!eventName.includes(".")) {
  44.                 if (!eventPooler[eventName]) return;
  45.                 delete eventPooler[eventName];
  46.             } else {
  47.                 let nameSpace = getNamespace(eventName);
  48.                 try{
  49.                     delete eventPooler[nameSpace.major][nameSpace.minor];
  50.                 } catch(e) {
  52.                 }
  53.             }
  55.         }
  57.         this.emmit = (eventName, ...args)=> {
  58.             const nameSpace = getNamespace(eventName);
  59.             if (!eventPooler[nameSpace.major]) return;
  60.             if (!eventName.includes(".")) {
  61.                 for (let minor in eventPooler[nameSpace.major]) {
  62.                     for (let i in eventPooler[nameSpace.major][minor]) {
  63.                         eventPooler[nameSpace.major][minor][i].fn.apply(this, args);
  64.                         if (eventPooler[nameSpace.major][minor][i].one) {
  65.                             delete eventPooler[nameSpace.major][minor][i];
  66.                             if (Object.keys(eventPooler[nameSpace.major][minor]).length == 0 ) delete eventPooler[nameSpace.major][minor];
  67.                         }
  68.                     }
  69.                 }
  70.             } else {
  71.                 if (!eventPooler[nameSpace.major][nameSpace.minor]) return;
  72.                 for (let i in eventPooler[nameSpace.major][nameSpace.minor]) {
  73.                     eventPooler[nameSpace.major][nameSpace.minor][i].fn.apply(this, args);
  74.                     if (eventPooler[nameSpace.major][nameSpace.minor][i].one) {
  75.                         delete eventPooler[nameSpace.major][nameSpace.minor][i];
  76.                         if (Object.keys(eventPooler[nameSpace.major][nameSpace.minor]).length == 0 ) delete eventPooler[nameSpace.major][nameSpace.minor];
  78.                     }
  79.                 }
  80.             }
  81.         }
  83.         this.hasEvent = (eventName) => {
  84.             try {
  85.                 const nameSpace = getNamespace(eventName);
  86.                 if (!eventPooler[nameSpace.major]) return false;
  87.     
  88.                 if (!eventName.includes(".")) {
  89.                     if (Object.keys(eventPooler[nameSpace.major]).length > 0 ) return true;
  90.                 } else {
  91.                     if (Object.keys(eventPooler[nameSpace.major][nameSpace.minor]).length > 0) return true;
  92.                 }
  93.                 return false;
  94.             } catch (e) {
  95.                 return false;
  96.             }
  98.         }
  100.         this.trigger = this.emmit;
  101.     }
  102. }
  106. /**
  107.  * A simple indexedDB handler to store [LocalStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) like key value pair... except, it is better.
  108.  * The benefits are:
  109.  * - Can store large amount of data.
  110.  * - Asynchronous and non-blocking.
  111.  * - Loaded on demand unlike LocalStorage.
  112.  * - Can store JavaScript object data.
  113.  * @class
  114.  * @param {String} [dbName=commonDB] - The DB name
  115.  * @param {String} [tableName=keyValuePairs] - Table name
  116.  * @memberof common
  117.  * @example <caption>Basic usage</caption>
  118.  * var myStorage = new DB();
  119.  * 
  120.  * //store a value to "someKey"
  121.  * await myStorage.set("someKey", {"someObject" : "with the value"}):
  122.  * 
  123.  * //get the value of "someKey"
  124.  * await myStorage.get("someKey");
  125.  * // will returns:
  126.  * {
  127.  *    "someObject": "with the value"
  128.  * }
  129.  */
  130. const SimpleDB = function(dbName="commonDB", tableName="keyValuePairs") {
  131.     const evt = new BasicEventHandler();
  132. 	this.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB || window.shimIndexedDB;
  133. 	this.dbName = dbName || "commonDB";
  134. 	this.tableName = tableName || "keyValuePairs";
  135. 	this.readyPromise = new Promise((resolve) => {
  136. 		this.resolver = resolve;
  137. 	});
  139.     
  140.     const initTransaction = async () => {
  141.         this.tx = this.db.transaction(this.tableName, "readwrite");
  142.         this.store = this.tx.objectStore(this.tableName);
  143.     }
  145.     const init = async () => {
  146.         return new Promise((resolve, reject) => {
  147.             this.connection = indexedDB.open(this.dbName, 1);
  148.             this.connected = false;
  149.         
  150.             this.connection.onupgradeneeded = () =>{
  151.                 this.db = this.connection.result;
  152.                 this.store = this.db.createObjectStore(this.tableName, {keyPath: "id"});
  153.                 //this.index = this.store.createIndex("NameIndex", ["name.last", "name.first"]);
  154.             };
  155.         
  156.             this.connection.onsuccess = () => {
  157.                 // Start a new transaction
  158.                 this.db = this.connection.result;
  159.                 this.tx = this.db.transaction(this.tableName, "readwrite");
  160.                 this.store = this.tx.objectStore(this.tableName);
  161.                 //this.index = this.store.index("NameIndex");
  162.                 this.isInitialized = true;
  163.                 this.resolver(this);
  164.                 resolve(this);
  165.             }
  166.         })
  167.     }
  169.     this.untilReady = async () => {
  170.         if (this.isInitialized) return this;
  171.         return init();
  172.     }
  174.     /**
  175.      * Set a value to the local DB
  176.      * @async
  177.      * @param {String} key - key of the key-value pair
  178.      * @param {*} value - Value of the key-value pair. Value can be anything. Unlike LocalStorage, if you can also store object in the DB.
  179.      * @returns {Promise<Event>} - Transaction event
  180.      */
  181.     this.set = async (key, value) => {
  182.         await this.untilReady();
  183.         evt.trigger("beforeSet", key, value);
  184.         var isChanged = false;
  185.         var prevValue
  186.         if (evt.hasEvent("change")) {
  187.             prevValue = await this.get(key);
  188.             if (JSON.stringify(prevValue) !== JSON.stringify(value)) isChanged = true;
  189.         }
  190.         return new Promise((resolve, reject) => {
  191.             initTransaction();
  192.             var request = this.store.put({id: key, value: value});
  193.             request.onsuccess = (e)=> {
  194.                 evt.trigger("set", key, value);
  195.                 if (isChanged) {
  196.                     evt.trigger("change", key, value, prevValue);
  197.                 }
  198.                 resolve(e)
  199.             }
  200.             request.onerror = (e)=> {
  201.                 reject(e)
  202.             }
  203.         })
  204.     }
  205.     this.setItem = this.set;
  207.     /**
  208.      * Get a value from local DB.
  209.      * @async
  210.      * @param {String} key  - key of the key-value pair
  211.      * @returns {Promise<*>} - The value
  212.      */
  213.     this.get = async (key) => {
  214.         await this.untilReady();
  215.         return new Promise((resolve, reject) => {
  216.             initTransaction();
  217.             var request = this.store.get(key);
  218.             request.onsuccess = (e)=> {
  219.                 if (!request.result) return resolve();
  220.                 resolve(request.result.value)
  221.             }
  222.             request.onerror = (e)=> {
  223.                 reject(e)
  224.             }
  225.         })
  226.     }
  228.     this.getItem = this.get;
  230.     /**
  231.      * Delete a record from local DB.
  232.      * @async
  233.      * @param {String} key  - key of the key-value pair
  234.      * @returns {Promise<Event>} - Transaction event
  235.      */
  236.     this.delete = async (key) => {
  237.         await this.untilReady();
  238.         evt.trigger("beforeDelete", key);
  240.         return new Promise((resolve, reject) => {
  241.             initTransaction();
  242.             var request = this.store.delete(key);
  243.             request.onsuccess = (e)=> {
  244.                 evt.trigger("delete", key);
  245.                 resolve(e)
  246.             }
  247.             request.onerror = (e)=> {
  248.                 reject(e)
  249.             }
  250.         })
  251.     }
  252.     this.removeItem = this.delete;
  254.     /**
  255.      * Clear a database.
  256.      * @returns {Promise<Event>} - Transaction event
  257.      */
  258.     this.clear = async () => {
  259.         await this.untilReady();
  260.         evt.trigger("beforeClear");
  262.         return new Promise((resolve, reject) => {
  263.             initTransaction();
  264.             var request = this.store.clear();
  265.             request.onsuccess = (e)=> {
  266.                 evt.trigger("clear", key);
  267.                 resolve(e)
  268.             }
  269.             request.onerror = (e)=> {
  270.                 reject(e)
  271.             }
  272.         })
  273.     }
  275.     this.on = (eventName, fn)=> {
  276.         evt.on(eventName, fn);
  277.     }
  279.     this.one = (eventName, fn)=> {
  280.         evt.one(eventName, fn);
  281.     }
  283.     this.off = (eventName) => {
  284.         evt.off(eventName);
  285.     }
  286. }
  289. module.exports = SimpleDB;