tiny-idb 1.1.0 → 1.2.0

package/README.md

@@ -17,13 +17,13 @@ Native IndexedDB requires managing requests, transactions, and version upgrades.
 The primary weakness of most storage wrappers is the "read-modify-write" race condition. If two parts of an application attempt to update the same key simultaneously, data loss often occurs. `tiny-idb` addresses this by executing `update`, `push`, and `merge` operations within a single IndexedDB transaction, ensuring that updates are processed sequentially and reliably.
 
 ### Resource Efficiency
-At only **611 bytes** (gzipped), the library introduces negligible overhead to your bundle. It is dependency-free and written in modern vanilla JavaScript, ensuring high performance across all environments that support IndexedDB.
+At **less than 1KB** (gzipped), the library introduces negligible overhead to your bundle. It is dependency-free and written in modern vanilla JavaScript, ensuring high performance across all environments that support IndexedDB.
 
 ### Intelligent Lifecycle Management
 The library handles database connection pooling, tab synchronization, and error recovery automatically. If a database connection is blocked by another tab or fails due to an environmental error, `tiny-idb` gracefully resets and recovers without requiring a page reload.
 
 ### Zero-Configuration Portability
-Beyond npm installation, `tiny-idb` is designed for maximum portability. As a single-file, dependency-free module, it can be integrated into any environment by simply dropping `tiny-idb.js` into a project directory. This makes it an ideal solution for rapid prototyping, legacy system upgrades, and environments where complex build pipelines are unavailable.
+Beyond npm installation, `tiny-idb` is designed for maximum portability. As a single-file, dependency-free module, it can be integrated into any environment by simply dropping `tiny-idb.js` into a project directory. **No build step, compilation, or transpilation is required.** This makes it an ideal solution for rapid prototyping, legacy system upgrades, and environments where complex build pipelines are unavailable.
 
 ## Installation
 
@@ -39,7 +39,7 @@ npm install tiny-idb
 </script>
 ```
 
-*   **Minified Module**: `https://unpkg.com/tiny-idb/tiny-idb.min.js` (598 bytes gzipped)
+*   **Minified Module**: `https://unpkg.com/tiny-idb/tiny-idb.min.js` (less than 1KB gzipped)
 *   **Source**: `https://unpkg.com/tiny-idb/tiny-idb.js`
 
 ## Technical Comparison
@@ -47,7 +47,7 @@ npm install tiny-idb
 | Feature | localStorage | tiny-idb |
 |---------|--------------|----------|
 | **Execution** | Synchronous (Blocks UI) | Asynchronous (Non-blocking) |
-| **Storage Limit** | ~5-10MB | Disk-limited |
+| **Storage Limit** | ~5-10MB | Virtually unlimited (until disk is full) |
 | **Data Types** | Strings only | Objects, Blobs, Arrays, Numbers |
 | **Data Integrity** | Basic | ACID Compliant |
 | **Race Condition Safety** | None | Atomic `update`/`push`/`merge` |
@@ -56,6 +56,7 @@ npm install tiny-idb
 
 | Method | Description |
 |--------|-------------|
+| `open(db, store?)` | Creates or retrieves a cached instance. `store` defaults to `db` name. |
 | `get(key)` | Retrieves a value; returns `undefined` if not found. |
 | `set(key, value)` | Persists a value to the store. |
 | `remove(key)` | Deletes a specific key. |
@@ -111,8 +112,32 @@ const sid = await tinyIDB.getItem('session_id');
 await tinyIDB.removeItem('session_id');
 ```
 
+### Simple Custom Database
+If you only need one store per database, you can omit the `storeName`. It will automatically default to the same name as the database.
+```javascript
+// Creates/retrieves a DB named 'my-store' with an internal store also named 'my-store'
+const store = tinyIDB.open('my-store');
+
+await store.set('key', 'value');
+```
+
+### Multi-Instance Support
+Use `open` to create isolated storage instances. Instances are cached internally.
+```javascript
+import { tinyIDB } from 'tiny-idb';
+
+// Create isolated storage instances
+const settings = tinyIDB.open('app-db', 'settings');
+const cache = tinyIDB.open('app-db', 'cache');
+
+await settings.set('theme', 'dark');
+await cache.set('temp_data', { id: 1 });
+```
+
 ## Development
 
+`tiny-idb` is written in pure vanilla JavaScript. No compilation is required for development.
+
 ### Running Tests
 ```bash
 npm test
@@ -123,9 +148,10 @@ npm test
 npm run test:min
 ```
 
-### Build
+### Minification
+Generate the production-ready minified file:
 ```bash
-npm run build
+npm run minify
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-idb",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "An extremely fast, super simple, and dependency-free IndexedDB wrapper. A drop-in replacement for localStorage with reliability and durability.",
   "main": "tiny-idb.js",
   "module": "tiny-idb.js",
@@ -40,6 +40,6 @@
   "scripts": {
     "test": "node test.js",
     "test:min": "TEST_MIN=1 node test.js",
-    "build": "terser tiny-idb.js -o tiny-idb.min.js -c toplevel,unsafe -m toplevel --comments false"
+    "minify": "terser tiny-idb.js -o tiny-idb.min.js -c toplevel,unsafe -m toplevel --comments false"
   }
 }

package/tiny-idb.js

@@ -6,56 +6,66 @@
  * @license MIT
  */
 
-const DB_NAME = 'tiny-idb', STORE_NAME = 's', READ_WRITE = 'readwrite', READ_ONLY = 'readonly';
-let dbPromise;
-
-const getDB = () => dbPromise || (dbPromise = new Promise((resolve, reject) => {
-  const req = indexedDB.open(DB_NAME, 1);
-  req.onupgradeneeded = () => req.result.createObjectStore(STORE_NAME);
-  req.onsuccess = () => {
-    const db = req.result;
-    db.onversionchange = () => { db.close(); dbPromise = null; };
-    resolve(db);
-  };
-  req.onerror = () => { dbPromise = null; reject(req.error); };
-}));
-
+const instances = new Map();
 const prom = (req) => new Promise((res, rej) => {
   req.onsuccess = () => res(req.result);
   req.onerror = () => rej(req.error);
 });
+const RO = 'readonly', RW = 'readwrite';
 
-const tx = async (mode, cb) => {
-  const db = await getDB();
-  return new Promise(async (resolve, reject) => {
-    const t = db.transaction(STORE_NAME, mode);
-    t.onabort = t.onerror = () => reject(t.error || new DOMException('Aborted'));
-    try {
-      const res = await cb(t.objectStore(STORE_NAME));
-      t.oncomplete = () => resolve(res);
-    } catch (e) {
-      try { t.abort(); } catch {}
-      reject(e);
-    }
-  });
-};
+const getAPI = (dbName = 'tiny-idb', storeName = undefined) => {
+  storeName = storeName || dbName;
+  const key = dbName + '\0' + storeName;
+  if (instances.has(key)) return instances.get(key);
+
+  let dbPromise;
+  const tx = async (mode, cb) => {
+    const db = await (dbPromise || (dbPromise = new Promise((resolve, reject) => {
+      const req = indexedDB.open(dbName, 1);
+      req.onupgradeneeded = () => req.result.createObjectStore(storeName);
+      req.onsuccess = () => {
+        const db = req.result;
+        db.onversionchange = () => { db.close(); dbPromise = null; };
+        resolve(db);
+      };
+      req.onerror = () => { dbPromise = null; reject(req.error); };
+    })));
+    return new Promise(async (resolve, reject) => {
+      const t = db.transaction(storeName, mode);
+      t.onabort = t.onerror = () => reject(t.error || new DOMException('Aborted'));
+      try {
+        const res = await cb(t.objectStore(storeName));
+        t.oncomplete = () => resolve(res);
+      } catch (e) {
+        try { t.abort(); } catch {}
+        reject(e);
+      }
+    });
+  };
 
-export const tinyIDB = {
-  set: (key, value) => tx(READ_WRITE, s => prom(s.put(value, key))),
-  get: key => tx(READ_ONLY, s => prom(s.get(key))),
-  remove: k => tx(READ_WRITE, s => prom(s.delete(k))),
-  clear: () => tx(READ_WRITE, s => prom(s.clear())),
-  keys: () => tx(READ_ONLY, s => prom(s.getAllKeys())),
-  values: () => tx(READ_ONLY, s => prom(s.getAll())),
-  count: () => tx(READ_ONLY, s => prom(s.count())),
-  update: async (key, fn) => tx(READ_WRITE, async s => {
+  const update = async (key, fn) => tx(RW, async s => {
     const n = await fn(await prom(s.get(key)));
     return prom(s.put(n, key));
-  }),
-  push: (key, value) => tinyIDB.update(key, c => [...(Array.isArray(c) ? c : []), value]),
-  merge: (key, patch) => tinyIDB.update(key, c => ({ ...(c && typeof c === 'object' ? c : {}), ...patch }))
-};
+  });
 
-['get', 'set', 'remove'].forEach(method => tinyIDB[method + 'Item'] = tinyIDB[method]);
+  const api = {
+    open: getAPI,
+    set: (key, value) => tx(RW, s => prom(s.put(value, key))),
+    get: key => tx(RO, s => prom(s.get(key))),
+    remove: k => tx(RW, s => prom(s.delete(k))),
+    clear: () => tx(RW, s => prom(s.clear())),
+    keys: () => tx(RO, s => prom(s.getAllKeys())),
+    values: () => tx(RO, s => prom(s.getAll())),
+    count: () => tx(RO, s => prom(s.count())),
+    update,
+    push: (key, value) => update(key, c => [...(Array.isArray(c) ? c : []), value]),
+    merge: (key, patch) => update(key, c => ({ ...(c && typeof c === 'object' ? c : {}), ...patch }))
+  };
+
+  ['get', 'set', 'remove'].forEach(m => api[m + 'Item'] = api[m]);
+  instances.set(key, api);
+  return api;
+};
 
+export const tinyIDB = getAPI();
 export default tinyIDB;

package/tiny-idb.min.js

@@ -1 +1 @@
-const e="readwrite",t="readonly";let r;const o=e=>new Promise((t,r)=>{e.onsuccess=()=>t(e.result),e.onerror=()=>r(e.error)}),n=async(e,t)=>{const o=await(r||(r=new Promise((e,t)=>{const o=indexedDB.open("tiny-idb",1);o.onupgradeneeded=()=>o.result.createObjectStore("s"),o.onsuccess=()=>{const t=o.result;t.onversionchange=()=>{t.close(),r=null},e(t)},o.onerror=()=>{r=null,t(o.error)}})));return new Promise(async(r,n)=>{const s=o.transaction("s",e);s.onabort=s.onerror=()=>n(s.error||new DOMException("Aborted"));try{const e=await t(s.objectStore("s"));s.oncomplete=()=>r(e)}catch(e){try{s.abort()}catch{}n(e)}})};export const tinyIDB={set:(t,r)=>n(e,e=>o(e.put(r,t))),get:e=>n(t,t=>o(t.get(e))),remove:t=>n(e,e=>o(e.delete(t))),clear:()=>n(e,e=>o(e.clear())),keys:()=>n(t,e=>o(e.getAllKeys())),values:()=>n(t,e=>o(e.getAll())),count:()=>n(t,e=>o(e.count())),update:async(t,r)=>n(e,async e=>{const n=await r(await o(e.get(t)));return o(e.put(n,t))}),push:(e,t)=>tinyIDB.update(e,e=>[...Array.isArray(e)?e:[],t]),merge:(e,t)=>tinyIDB.update(e,e=>({...e&&"object"==typeof e?e:{},...t}))};["get","set","remove"].forEach(e=>tinyIDB[e+"Item"]=tinyIDB[e]);export default tinyIDB;
+const e=new Map,t=e=>new Promise((t,r)=>{e.onsuccess=()=>t(e.result),e.onerror=()=>r(e.error)}),r="readonly",o="readwrite",n=(s="tiny-idb",c=void 0)=>{const a=s+"\0"+(c=c||s);if(e.has(a))return e.get(a);let l;const u=async(e,t)=>{const r=await(l||(l=new Promise((e,t)=>{const r=indexedDB.open(s,1);r.onupgradeneeded=()=>r.result.createObjectStore(c),r.onsuccess=()=>{const t=r.result;t.onversionchange=()=>{t.close(),l=null},e(t)},r.onerror=()=>{l=null,t(r.error)}})));return new Promise(async(o,n)=>{const s=r.transaction(c,e);s.onabort=s.onerror=()=>n(s.error||new DOMException("Aborted"));try{const e=await t(s.objectStore(c));s.oncomplete=()=>o(e)}catch(e){try{s.abort()}catch{}n(e)}})},i=async(e,r)=>u(o,async o=>{const n=await r(await t(o.get(e)));return t(o.put(n,e))}),y={open:n,set:(e,r)=>u(o,o=>t(o.put(r,e))),get:e=>u(r,r=>t(r.get(e))),remove:e=>u(o,r=>t(r.delete(e))),clear:()=>u(o,e=>t(e.clear())),keys:()=>u(r,e=>t(e.getAllKeys())),values:()=>u(r,e=>t(e.getAll())),count:()=>u(r,e=>t(e.count())),update:i,push:(e,t)=>i(e,e=>[...Array.isArray(e)?e:[],t]),merge:(e,t)=>i(e,e=>({...e&&"object"==typeof e?e:{},...t}))};return["get","set","remove"].forEach(e=>y[e+"Item"]=y[e]),e.set(a,y),y};export const tinyIDB=n();export default tinyIDB;