@ztimson/utils 0.25.8 → 0.25.9

package/dist/index.mjs

@@ -395,46 +395,88 @@ function makeArray(value) {
 class Database {
   constructor(database, tables, version) {
     __publicField(this, "connection");
+    __publicField(this, "ready", false);
     __publicField(this, "tables");
     this.database = database;
     this.version = version;
     this.connection = new Promise((resolve, reject) => {
       const req = indexedDB.open(this.database, this.version);
-      this.tables = tables.map((t) => {
+      this.tables = !tables ? [] : tables.map((t) => {
         t = typeof t == "object" ? t : { name: t };
         return { ...t, name: t.name.toString() };
       });
-      const tableNames = new ASet(this.tables.map((t) => t.name));
       req.onerror = () => reject(req.error);
       req.onsuccess = () => {
         const db = req.result;
-        if (tableNames.symmetricDifference(new ASet(Array.from(db.objectStoreNames))).length) {
+        const existing = Array.from(db.objectStoreNames);
+        if (!tables) this.tables = existing.map((t) => {
+          const tx = db.transaction(t, "readonly");
+          const store = tx.objectStore(t);
+          return { name: t, key: store.keyPath };
+        });
+        const desired = new ASet((tables || []).map((t) => typeof t == "string" ? t : t.name));
+        if (tables && desired.symmetricDifference(new ASet(existing)).length) {
           db.close();
           Object.assign(this, new Database(this.database, this.tables, db.version + 1));
+          this.connection.then(resolve);
         } else {
           this.version = db.version;
           resolve(db);
         }
+        this.ready = true;
       };
       req.onupgradeneeded = () => {
         const db = req.result;
         const existingTables = new ASet(Array.from(db.objectStoreNames));
-        existingTables.difference(tableNames).forEach((name) => db.deleteObjectStore(name));
-        tableNames.difference(existingTables).forEach((name) => db.createObjectStore(name));
+        if (tables) {
+          const desired = new ASet((tables || []).map((t) => typeof t == "string" ? t : t.name));
+          existingTables.difference(desired).forEach((name) => db.deleteObjectStore(name));
+          desired.difference(existingTables).forEach((name) => {
+            const t = this.tables.find(findByProp("name", name));
+            db.createObjectStore(name, {
+              keyPath: t == null ? void 0 : t.key,
+              autoIncrement: (t == null ? void 0 : t.autoIncrement) || !(t == null ? void 0 : t.key)
+            });
+          });
+        }
       };
     });
   }
+  async createTable(table) {
+    if (typeof table == "string") table = { name: table };
+    const conn = await this.connection;
+    if (!this.includes(table.name)) {
+      conn.close();
+      Object.assign(this, new Database(this.database, [...this.tables, table], (this.version ?? 0) + 1));
+    }
+    return this.table(table.name);
+  }
+  async deleteTable(table) {
+    if (typeof table == "string") table = { name: table };
+    if (!this.includes(table.name)) return;
+    const conn = await this.connection;
+    conn.close();
+    Object.assign(this, new Database(this.database, this.tables.filter((t) => t.name != table.name), (this.version ?? 0) + 1));
+  }
   includes(name) {
-    return !!this.tables.find((t) => t.name == name.toString());
+    return !!this.tables.find((t) => t.name == (typeof name == "object" ? name.name : name.toString()));
   }
   table(name) {
     return new Table(this, name.toString());
   }
 }
 class Table {
-  constructor(database, name) {
+  constructor(database, name, key = "id") {
+    __publicField(this, "all", this.getAll);
+    __publicField(this, "create", this.add);
+    __publicField(this, "update", this.set);
     this.database = database;
     this.name = name;
+    this.key = key;
+    this.database.connection.then(() => {
+      const exists = !!this.database.tables.find(findByProp("name", this.name));
+      if (!exists) this.database.createTable(this.name);
+    });
   }
   async tx(table, fn2, readonly = false) {
     const db = await this.database.connection;
@@ -449,11 +491,17 @@ class Table {
   add(value, key) {
     return this.tx(this.name, (store) => store.add(value, key));
   }
+  clear() {
+    return this.tx(this.name, (store) => store.clear());
+  }
   count() {
     return this.tx(this.name, (store) => store.count(), true);
   }
-  put(key, value) {
-    return this.tx(this.name, (store) => store.put(value, key));
+  delete(key) {
+    return this.tx(this.name, (store) => store.delete(key));
+  }
+  get(key) {
+    return this.tx(this.name, (store) => store.get(key), true);
   }
   getAll() {
     return this.tx(this.name, (store) => store.getAll(), true);
@@ -461,14 +509,15 @@ class Table {
   getAllKeys() {
     return this.tx(this.name, (store) => store.getAllKeys(), true);
   }
-  get(key) {
-    return this.tx(this.name, (store) => store.get(key), true);
+  put(key, value) {
+    return this.tx(this.name, (store) => store.put(value, key));
   }
-  delete(key) {
-    return this.tx(this.name, (store) => store.delete(key));
+  read(key) {
+    return key ? this.get(key) : this.getAll();
   }
-  clear() {
-    return this.tx(this.name, (store) => store.clear());
+  set(value, key) {
+    if (!key && !value[this.key]) return this.add(value);
+    return this.put(key || value[this.key], value);
   }
 }
 class Cache {