@preference-sl/pref-viewer 2.10.0-beta.5 → 2.10.0-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preference-sl/pref-viewer",
-  "version": "2.10.0-beta.5",
+  "version": "2.10.0-beta.6",
   "description": "Web Component to preview GLTF models with Babylon.js",
   "author": "Alex Moreno Palacio <amoreno@preference.es>",
   "scripts": {

package/src/gltf-storage.js

@@ -1,148 +1,253 @@
-// Inicializar IndexedDB
+// wwwroot/js/gltf-storage.js
+
+// Public, inspectable namespace
+const PC = (globalThis.PrefConfigurator ??= {});
+PC.version = PC.version ?? "1.0.1"; // bump if you change schema
+PC.db = PC.db ?? null;              // public handle (no private state)
+
+function _getDbOrThrow() {
+  const db = PC.db;
+  if (!db) throw new Error("Database not initialized. Call initDb(...) first.");
+  return db;
+}
+
+// --- internal helpers -------------------------------------------------------
+
+function _createStoreIfMissing(db, storeName) {
+  if (!db.objectStoreNames.contains(storeName)) {
+    const store = db.createObjectStore(storeName, { keyPath: "id" });
+    store.createIndex("expirationTimeStamp", "expirationTimeStamp", { unique: false });
+  }
+}
+
+/**
+ * Opens a DB without specifying a version. If the required object store doesn't
+ * exist, it re-opens with (currentVersion + 1) to create it.
+ */
+function _openEnsuringStore(dbName, storeName) {
+  return new Promise((resolve, reject) => {
+    const open = indexedDB.open(dbName);
+
+    open.onblocked = () => reject(new Error("Open blocked by another tab or worker"));
+    open.onerror = () => reject(open.error);
+
+    open.onupgradeneeded = (e) => {
+      // First creation path (brand-new DB)
+      const db = e.target.result;
+      _createStoreIfMissing(db, storeName);
+    };
+
+    open.onsuccess = (e) => {
+      const db = e.target.result;
+
+      // If the store exists, we're done.
+      if (db.objectStoreNames.contains(storeName)) {
+        resolve(db);
+        return;
+      }
+
+      // Otherwise bump version just enough to add the store.
+      const nextVersion = db.version + 1;
+      db.close();
+
+      const upgrade = indexedDB.open(dbName, nextVersion);
+      upgrade.onblocked = () => reject(new Error("Upgrade blocked by another tab or worker"));
+      upgrade.onerror = () => reject(upgrade.error);
+      upgrade.onupgradeneeded = (ev) => {
+        const upDb = ev.target.result;
+        _createStoreIfMissing(upDb, storeName);
+      };
+      upgrade.onsuccess = (ev) => resolve(ev.target.result);
+    };
+  });
+}
+
+// --- public API -------------------------------------------------------------
+
+// Inicializar IndexedDB y dejar el handle en PrefConfigurator.db (público)
 export async function initDb(dbName, storeName) {
-    return new Promise((resolve, reject) => {
-        const request = indexedDB.open(dbName, 1);
-
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => {
-            window.gltfDB = request.result;
-            resolve();
-        };
-
-        request.onupgradeneeded = (event) => {
-            const db = event.target.result;
-            if (!db.objectStoreNames.contains(storeName)) {
-                const store = db.createObjectStore(storeName, { keyPath: "id" });
-                store.createIndex("type", "type", { unique: false });
-                store.createIndex("timestamp", "timestamp", { unique: false });
-            }
-        };
-    });
+  const db = await _openEnsuringStore(dbName, storeName);
+
+  // Close any previous handle to avoid versionchange blocking
+  try { PC.db?.close?.(); } catch {}
+  PC.db = db;
+
+  // If another tab upgrades, close gracefully so next call can re-init
+  db.onversionchange = () => {
+    try { db.close(); } catch {}
+    if (PC.db === db) PC.db = null;
+    console.warn("[PrefConfigurator] DB connection closed due to versionchange. Re-run initDb().");
+  };
 }
 
 // Guardar modelo
 export async function saveModel(modelDataStr, storeName) {
-    return new Promise((resolve, reject) => {
-        if (!window.gltfDB) {
-            reject(new Error("Database not initialized"));
-            return;
-        }
-        let modelData = JSON.parse(modelDataStr);
-
-        const dataToStore = {
-            ...modelData,
-            data: modelData.data,
-            size: modelData.data.length,
-            timestamp: new Date().toISOString(),
-        };
-
-        const transaction = window.gltfDB.transaction([storeName], "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.put(dataToStore);
-
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve();
-    });
+  return new Promise((resolve, reject) => {
+    let db;
+    try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
+
+    let modelData;
+    try { modelData = JSON.parse(modelDataStr); }
+    catch (e) { reject(new Error("saveModel: modelDataStr is not valid JSON")); return; }
+
+    const dataToStore = {
+      ...modelData,
+      data: modelData.data,
+      size: (modelData?.data?.length ?? 0)
+    };
+
+    const tx = db.transaction([storeName], "readwrite");
+    const store = tx.objectStore(storeName);
+    const req = store.put(dataToStore);
+
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve();
+  });
 }
 
 // Cargar modelo
 export function loadModel(modelId, storeName) {
-    return new Promise((resolve, reject) => {
-        if (!globalThis.gltfDB) {
-            reject(new Error("Database not initialized"));
-            return;
-        }
-        const tx = globalThis.gltfDB.transaction([storeName], "readonly");
-        const store = tx.objectStore(storeName);
-        const req = store.get(modelId);
-        req.onerror = () => reject(req.error);
-        req.onsuccess = () => resolve(req.result ?? null);
-    });
+  return new Promise((resolve, reject) => {
+    let db;
+    try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
+
+    const tx = db.transaction([storeName], "readonly");
+    const store = tx.objectStore(storeName);
+    const req = store.get(modelId);
+
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve(req.result ?? null);
+  });
 }
 
+// Descargar archivo desde base64
 export function downloadFileFromBytes(fileName, bytesBase64, mimeType) {
-    const link = document.createElement("a");
-    link.download = fileName;
-    link.href = `data:${mimeType};base64,${bytesBase64}`;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
+  const link = document.createElement("a");
+  link.download = fileName;
+  link.href = `data:${mimeType};base64,${bytesBase64}`;
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
 }
 
 // Obtener todos los modelos (solo metadata)
 export async function getAllModels(storeName) {
-    return new Promise((resolve, reject) => {
-        if (!window.gltfDB) {
-            reject(new Error("Database not initialized"));
-            return;
-        }
-
-        const transaction = window.gltfDB.transaction([storeName], "readonly");
-        const store = transaction.objectStore(storeName);
-        const request = store.getAll();
-
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => {
-            // Excluir los datos binarios para evitar transferir demasiados datos
-            const results = request.result.map((item) => ({
-                id: item.id,
-                metadata: item.metadata,
-                timestamp: item.timestamp,
-                size: item.size,
-                type: item.type,
-            }));
-            resolve(JSON.stringify(results));
-        };
-    });
+  return new Promise((resolve, reject) => {
+    let db;
+    try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
+
+    const tx = db.transaction([storeName], "readonly");
+    const store = tx.objectStore(storeName);
+    const req = store.getAll();
+
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => {
+      const items = Array.isArray(req.result) ? req.result : [];
+      const results = items.map(item => ({
+        id: item.id,
+        metadata: item.metadata,
+        timeStamp: item.timeStamp,
+        size: item.size
+      }));
+      // keep old behavior: return JSON string
+      resolve(JSON.stringify(results));
+    };
+  });
 }
 
-// Eliminar modelo
+// Eliminar modelo por id
 export async function deleteModel(modelId, storeName) {
-    return new Promise((resolve, reject) => {
-        if (!window.gltfDB) {
-            reject(new Error("Database not initialized"));
-            return;
-        }
-
-        const transaction = window.gltfDB.transaction([storeName], "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.delete(modelId);
-
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve();
-    });
+  return new Promise((resolve, reject) => {
+    let db;
+    try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
+
+    const tx = db.transaction([storeName], "readwrite");
+    const store = tx.objectStore(storeName);
+    const req = store.delete(modelId);
+
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve();
+  });
 }
 
-// Limpiar toda la base de datos
+// Limpiar toda la store
 export async function clearAll(storeName) {
-    return new Promise((resolve, reject) => {
-        if (!window.gltfDB) {
-            reject(new Error("Database not initialized"));
-            return;
-        }
-
-        const transaction = window.gltfDB.transaction([storeName], "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.clear();
-
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve();
-    });
+  return new Promise((resolve, reject) => {
+    let db;
+    try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
+
+    const tx = db.transaction([storeName], "readwrite");
+    const store = tx.objectStore(storeName);
+    const req = store.clear();
+
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve();
+  });
 }
 
-(function attachPublicAPI(global) {
-    const root = (global.PrefConfigurator ??= {});
-    const storage = {
-        initDb,
-        saveModel,
-        loadModel,
-        getAllModels,
-        deleteModel,
-        clearAll,
-        downloadFileFromBytes,
+// Borrar modelos expirados usando el índice "expirationTimeStamp"
+export async function cleanExpiredModels(storeName) {
+  return new Promise((resolve, reject) => {
+    let db;
+    try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
+
+    const tx = db.transaction([storeName], "readwrite");
+    const store = tx.objectStore(storeName);
+
+    const index = store.index("expirationTimeStamp");
+    const now = Date.now();
+    const range = IDBKeyRange.upperBound(now);
+    const cursorRequest = index.openCursor(range);
+
+    cursorRequest.onerror = () => reject(cursorRequest.error);
+    cursorRequest.onsuccess = (event) => {
+      const cursor = event.target.result;
+      if (cursor) {
+        cursor.delete();
+        cursor.continue();
+      }
     };
 
-    // versionado del módulo público
-    root.version = root.version ?? "1.0.0";
-    root.storage = Object.freeze(storage);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+// Utilidades opcionales y visibles (para usar en consola)
+export function closeDb() {
+  if (PC.db) {
+    try { PC.db.close(); } catch {}
+    PC.db = null;
+  }
+}
+
+export function deleteDatabase(dbName) {
+  return new Promise((resolve, reject) => {
+    if (PC.db && PC.db.name === dbName) {
+      try { PC.db.close(); } catch {}
+      PC.db = null;
+    }
+    const req = indexedDB.deleteDatabase(dbName);
+    req.onblocked = () => reject(new Error("Delete blocked by another tab or worker"));
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve();
+  });
+}
+
+// Attach a frozen, public API (no private state)
+(function attachPublicAPI(global) {
+  const storage = {
+    initDb,
+    saveModel,
+    loadModel,
+    getAllModels,
+    deleteModel,
+    clearAll,
+    cleanExpiredModels,
+    downloadFileFromBytes,
+    // extras
+    closeDb,
+    deleteDatabase,
+  };
+  global.PrefConfigurator.storage = Object.freeze(storage);
 })(globalThis);