@ztimson/utils 0.25.1 → 0.25.3

package/dist/cache.d.ts

@@ -1,9 +1,9 @@
-import { Collection } from './database.ts';
+import { Table } from './database.ts';
 export type CacheOptions = {
     /** Delete keys automatically after x amount of seconds */
     ttl?: number;
     /** Storage to persist cache */
-    storage?: Storage | Collection<any, any>;
+    storage?: Storage | Table<any, any>;
     /** Key cache will be stored under */
     storageKey?: string;
     /** Keep or delete cached items once expired, defaults to delete */
@@ -72,6 +72,7 @@ export declare class Cache<K extends string | number | symbol, T> {
     /**
      * Get item from the cache
      * @param {K} key Key to lookup
+     * @param expired Include expired items
      * @return {T} Cached item
      */
     get(key: K, expired?: boolean): CachedValue<T> | null;

package/dist/database.d.ts

@@ -1,11 +1,21 @@
-export declare class Collection<K extends IDBValidKey, T> {
-    readonly db: string;
-    readonly collection: string;
-    readonly version?: number | undefined;
-    private setup?;
-    private database;
-    constructor(db: string, collection: string, version?: number | undefined, setup?: ((db: IDBDatabase, event: IDBVersionChangeEvent) => void) | undefined);
-    tx<T>(collection: string, fn: ((store: IDBObjectStore) => IDBRequest), readonly?: boolean): Promise<T>;
+export type TableOptions = {
+    name: string;
+    key?: string;
+};
+export declare class Database {
+    readonly database: string;
+    readonly tables: (string | TableOptions)[];
+    version?: number | undefined;
+    connection: Promise<IDBDatabase>;
+    constructor(database: string, tables: (string | TableOptions)[], version?: number | undefined);
+    includes(name: string): boolean;
+    table<K extends IDBValidKey = any, T = any>(name: string): Table<K, T>;
+}
+export declare class Table<K extends IDBValidKey = any, T = any> {
+    private readonly database;
+    readonly name: string;
+    constructor(database: Database, name: string);
+    tx<R>(schema: string, fn: (store: IDBObjectStore) => IDBRequest, readonly?: boolean): Promise<R>;
     add(value: T, key?: K): Promise<void>;
     count(): Promise<number>;
     put(key: K, value: T): Promise<void>;

package/dist/index.cjs

@@ -396,28 +396,52 @@ ${opts.message || this.desc}`;
   function makeArray(value) {
     return Array.isArray(value) ? value : [value];
   }
-  class Collection {
-    constructor(db, collection, version, setup) {
-      __publicField(this, "database");
-      this.db = db;
-      this.collection = collection;
+  class Database {
+    constructor(database, tables, version) {
+      __publicField(this, "connection");
+      this.database = database;
+      this.tables = tables;
       this.version = version;
-      this.setup = setup;
-      this.database = new Promise((resolve, reject) => {
-        const req = indexedDB.open(this.db, this.version);
+      this.connection = new Promise((resolve, reject) => {
+        const req = indexedDB.open(this.database, this.version);
         req.onerror = () => reject(req.error);
-        req.onsuccess = () => resolve(req.result);
-        req.onupgradeneeded = (event) => {
-          const db2 = req.result;
-          if (!db2.objectStoreNames.contains(collection)) db2.createObjectStore(collection, { keyPath: void 0 });
-          if (this.setup) this.setup(db2, event);
+        req.onsuccess = () => {
+          const db = req.result;
+          if (tables.find((s) => !db.objectStoreNames.contains(typeof s === "string" ? s : s.name))) {
+            db.close();
+            Object.assign(this, new Database(this.database, this.tables, db.version + 1));
+          } else {
+            this.version = db.version;
+            resolve(db);
+          }
+        };
+        req.onupgradeneeded = () => {
+          const db = req.result;
+          Array.from(db.objectStoreNames).filter((s) => !this.tables.find((t) => typeof t === "string" ? t : t.name == s)).forEach((name) => db.deleteObjectStore(name));
+          tables.filter((t) => !db.objectStoreNames.contains(typeof t === "string" ? t : t.name)).forEach((t) => {
+            db.createObjectStore(typeof t === "string" ? t : t.name, {
+              keyPath: typeof t === "string" ? void 0 : t.key
+            });
+          });
         };
       });
     }
-    async tx(collection, fn2, readonly) {
-      const db = await this.database;
-      const tx = db.transaction(collection, readonly ? "readonly" : "readwrite");
-      const store = tx.objectStore(collection);
+    includes(name) {
+      return this.tables.some((t) => typeof t === "string" ? name === t : name === t.name);
+    }
+    table(name) {
+      return new Table(this, name);
+    }
+  }
+  class Table {
+    constructor(database, name) {
+      this.database = database;
+      this.name = name;
+    }
+    async tx(schema, fn2, readonly = false) {
+      const db = await this.database.connection;
+      const tx = db.transaction(schema, readonly ? "readonly" : "readwrite");
+      const store = tx.objectStore(schema);
       return new Promise((resolve, reject) => {
         const request = fn2(store);
         request.onsuccess = () => resolve(request.result);
@@ -425,29 +449,28 @@ ${opts.message || this.desc}`;
       });
     }
     add(value, key) {
-      return this.tx(this.collection, (store) => store.add(value, key));
+      return this.tx(this.name, (store) => store.add(value, key));
     }
     count() {
-      return this.tx(this.collection, (store) => store.count(), true);
+      return this.tx(this.name, (store) => store.count(), true);
     }
     put(key, value) {
-      debugger;
-      return this.tx(this.collection, (store) => store.put(value, key));
+      return this.tx(this.name, (store) => store.put(value, key));
     }
     getAll() {
-      return this.tx(this.collection, (store) => store.getAll(), true);
+      return this.tx(this.name, (store) => store.getAll(), true);
     }
     getAllKeys() {
-      return this.tx(this.collection, (store) => store.getAllKeys(), true);
+      return this.tx(this.name, (store) => store.getAllKeys(), true);
     }
     get(key) {
-      return this.tx(this.collection, (store) => store.get(key), true);
+      return this.tx(this.name, (store) => store.get(key), true);
     }
     delete(key) {
-      return this.tx(this.collection, (store) => store.delete(key));
+      return this.tx(this.name, (store) => store.delete(key));
     }
     clear() {
-      return this.tx(this.collection, (store) => store.clear());
+      return this.tx(this.name, (store) => store.clear());
     }
   }
   class Cache {
@@ -470,10 +493,13 @@ ${opts.message || this.desc}`;
       this.options = options;
       if (options.storageKey && !options.storage && typeof Storage !== "undefined") options.storage = localStorage;
       if (options.storage) {
-        if (options.storage instanceof Collection) {
+        if (options.storage instanceof Table) {
           (async () => {
             var _a2;
-            (await ((_a2 = options.storage) == null ? void 0 : _a2.getAll())).forEach((v) => this.add(v));
+            return (await ((_a2 = options.storage) == null ? void 0 : _a2.getAll())).forEach((v) => {
+              console.log(v);
+              this.add(v);
+            });
           })();
         } else if (options.storageKey) {
           const stored = (_a = options.storage) == null ? void 0 : _a.getItem(options.storageKey);
@@ -501,7 +527,7 @@ ${opts.message || this.desc}`;
     }
     save(key) {
       if (this.options.storage) {
-        if (this.options.storage instanceof Collection) {
+        if (this.options.storage instanceof Table) {
           this.options.storage.put(key, this.store[key]);
         } else if (this.options.storageKey) {
           this.options.storage.setItem(this.options.storageKey, JSONSanitize(this.store));
@@ -568,13 +594,16 @@ ${opts.message || this.desc}`;
      */
     expire(key) {
       this.complete = false;
-      if (this.options.expiryPolicy == "keep") this.store[key]._expired = true;
-      else this.delete(key);
+      if (this.options.expiryPolicy == "keep") {
+        this.store[key]._expired = true;
+        this.save(key);
+      } else this.delete(key);
       return this;
     }
     /**
      * Get item from the cache
      * @param {K} key Key to lookup
+     * @param expired Include expired items
      * @return {T} Cached item
      */
     get(key, expired) {
@@ -2002,8 +2031,8 @@ ${opts.message || this.desc}`;
   exports2.CliBackground = CliBackground;
   exports2.CliEffects = CliEffects;
   exports2.CliForeground = CliForeground;
-  exports2.Collection = Collection;
   exports2.CustomError = CustomError;
+  exports2.Database = Database;
   exports2.ForbiddenError = ForbiddenError;
   exports2.GatewayTimeoutError = GatewayTimeoutError;
   exports2.Http = Http;
@@ -2028,6 +2057,7 @@ ${opts.message || this.desc}`;
   exports2.PromiseProgress = PromiseProgress;
   exports2.SYMBOL_LIST = SYMBOL_LIST;
   exports2.ServiceUnavailableError = ServiceUnavailableError;
+  exports2.Table = Table;
   exports2.TypedEmitter = TypedEmitter;
   exports2.UnauthorizedError = UnauthorizedError;
   exports2.addUnique = addUnique;