@ztimson/utils 0.25.8 → 0.25.9

package/dist/database.d.ts

@@ -1,27 +1,38 @@
 export type TableOptions = {
     name: string;
     key?: string;
+    autoIncrement?: boolean;
 };
 export declare class Database {
     readonly database: string;
     version?: number | undefined;
     connection: Promise<IDBDatabase>;
+    ready: boolean;
     tables: TableOptions[];
-    constructor(database: string, tables: (string | TableOptions)[], version?: number | undefined);
+    constructor(database: string, tables?: (string | TableOptions)[], version?: number | undefined);
+    createTable<K extends IDBValidKey = any, T = any>(table: string | TableOptions): Promise<Table<K, T>>;
+    deleteTable(table: string | TableOptions): Promise<void>;
     includes(name: any): boolean;
     table<K extends IDBValidKey = any, T = any>(name: any): Table<K, T>;
 }
 export declare class Table<K extends IDBValidKey = any, T = any> {
     private readonly database;
     readonly name: string;
-    constructor(database: Database, name: string);
+    readonly key: keyof T | string;
+    constructor(database: Database, name: string, key?: keyof T | string);
     tx<R>(table: string, fn: (store: IDBObjectStore) => IDBRequest, readonly?: boolean): Promise<R>;
     add(value: T, key?: K): Promise<void>;
+    all: () => Promise<T[]>;
+    clear(): Promise<void>;
     count(): Promise<number>;
-    put(key: K, value: T): Promise<void>;
+    create: (value: T, key?: K) => Promise<void>;
+    delete(key: K): Promise<void>;
+    get(key: K): Promise<T>;
     getAll(): Promise<T[]>;
     getAllKeys(): Promise<K[]>;
-    get(key: K): Promise<T>;
-    delete(key: K): Promise<void>;
-    clear(): Promise<void>;
+    put(key: K, value: T): Promise<void>;
+    read(): Promise<T[]>;
+    read(key: K): Promise<T>;
+    set(value: T, key?: K): Promise<void>;
+    update: (value: T, key?: K) => Promise<void>;
 }

package/dist/index.cjs

@@ -399,46 +399,88 @@ ${opts.message || this.desc}`;
   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;
@@ -453,11 +495,17 @@ ${opts.message || this.desc}`;
     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);
@@ -465,14 +513,15 @@ ${opts.message || this.desc}`;
     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 {