remult 3.3.6 → 3.3.8

package/esm/server/remult-admin-html.js

@@ -0,0 +1,13 @@
+import { getHtml } from './get-remult-admin-html.js';
+export default function remultAdminHtml(options) {
+    const { head, rootPath, requireAuthToken, disableLiveQuery } = options;
+    return getHtml()
+        .replace('<!--PLACE_HERE_HEAD-->', head)
+        .replace('<!--PLACE_HERE_BODY-->', `<script>
+  window.optionsFromServer = ${JSON.stringify({
+        rootPath,
+        requireAuthToken,
+        disableLiveQuery,
+    })}
+</script>`);
+}

package/esm/server/remult-admin.js

@@ -1,20 +1,7 @@
 import { getRelationFieldInfo, } from '../src/remult3/relationInfoMember.js';
 import { Filter } from '../src/filter/filter-interfaces.js';
-import { getHtml } from './get-remult-admin-html.js';
 import { getValueList } from '../src/remult3/RepositoryImplementation.js';
 import { InputTypes } from '../inputTypes.js';
-export default function remultAdminHtml(options) {
-    const { head, rootPath, requireAuthToken, disableLiveQuery } = options;
-    return getHtml()
-        .replace('<!--PLACE_HERE_HEAD-->', head)
-        .replace('<!--PLACE_HERE_BODY-->', `<script>
-  window.optionsFromServer = ${JSON.stringify({
-        rootPath,
-        requireAuthToken,
-        disableLiveQuery,
-    })}
-</script>`);
-}
 export function buildEntityInfo(options) {
     const entities = [];
     for (const metadata of options.entities.map((e) => options.remult.repo(e).metadata)) {

package/esm/server/remult-api-server.js

@@ -11,7 +11,7 @@ import { getEntityKey } from '../src/remult3/getEntityRef.js';
 import { Action, classBackendMethodsArray } from '../src/server-action.js';
 import { serverActionField } from '../src/server-action-info.js';
 import { remultStatic } from '../src/remult-static.js';
-import remultAdminHtml, { buildEntityInfo } from './remult-admin.js';
+import { buildEntityInfo } from './remult-admin.js';
 import { isOfType } from '../src/isOfType.js';
 import { initDataProviderOrJson } from './initDataProviderOrJson.js';
 import { modulesFlatAndOrdered } from './module.js';
@@ -246,6 +246,10 @@ export class RemultServerImplementation {
                                 disableLiveQuery =
                                     this.options.admin.disableLiveQuery ?? disableLiveQuery;
                             }
+                            // Lazy-load the ~1.4MB admin HTML module only when the admin
+                            // page is actually requested, so it is never pulled into the
+                            // bundle of apps that don't serve the admin UI.
+                            const { default: remultAdminHtml } = await import('./remult-admin-html.js');
                             origResponse.send(remultAdminHtml({
                                 rootPath: this.options.rootPath ?? '/api',
                                 head,

package/esm/src/data-providers/json-entity-indexed-db-data-provider.js

@@ -8,66 +8,60 @@ export class JsonEntityIndexedDbStorage {
     supportsRawJson = true;
     //@internal
     db;
-    async getItem(entityDbName) {
-        return new Promise(async (resolve, reject) => {
-            const transaction = (await this.init()).transaction([this.storeName], 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.get(entityDbName);
-            request.onerror = (event) => reject(request.error);
-            request.onsuccess = (event) => {
-                if (request.result) {
-                    resolve(request.result);
-                }
-                else {
-                    resolve(null);
-                }
-            };
-        });
+    getItem(entityDbName) {
+        return this.run('readonly', (s) => s.get(entityDbName));
+    }
+    setItem(entityDbName, json) {
+        return this.run('readwrite', (s) => s.put(json, entityDbName));
+    }
+    removeItem(entityDbName) {
+        return this.run('readwrite', (s) => s.delete(entityDbName));
+    }
+    clear() {
+        return this.run('readwrite', (s) => s.clear());
     }
     //@internal
-    async init() {
-        if (!this.db) {
-            this.db = await new Promise((resolve, reject) => {
-                let db;
-                const request = indexedDB.open(this.dbName, 1);
-                request.onerror = (event) => reject(request.error);
-                request.onsuccess = (event) => {
-                    db = request.result;
-                    resolve(db);
-                };
-                request.onupgradeneeded = (event) => {
-                    db = request.result;
-                    db.createObjectStore(this.storeName);
-                };
+    async run(mode, op) {
+        const attempt = async () => {
+            const db = await this.init();
+            return new Promise((resolve, reject) => {
+                const request = op(db.transaction([this.storeName], mode).objectStore(this.storeName));
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve(request.result ?? null);
             });
+        };
+        try {
+            return await attempt();
+        }
+        catch (err) {
+            if (err?.name !== 'InvalidStateError')
+                throw err;
+            this.db = undefined;
+            return await attempt();
         }
-        return this.db;
-    }
-    async setItem(entityDbName, json) {
-        return new Promise(async (resolve, reject) => {
-            const transaction = (await this.init()).transaction([this.storeName], 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.put(json, entityDbName);
-            request.onerror = (event) => reject(request.error);
-            request.onsuccess = (event) => resolve();
-        });
-    }
-    async removeItem(entityDbName) {
-        return new Promise(async (resolve, reject) => {
-            const transaction = (await this.init()).transaction([this.storeName], 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.delete(entityDbName);
-            request.onerror = (_event) => reject(request.error);
-            request.onsuccess = (_event) => resolve();
-        });
     }
-    async clear() {
-        return new Promise(async (resolve, reject) => {
-            const transaction = (await this.init()).transaction([this.storeName], 'readwrite');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.clear();
-            request.onerror = (_event) => reject(request.error);
-            request.onsuccess = (_event) => resolve();
+    //@internal
+    async init() {
+        if (this.db)
+            return this.db;
+        this.db = await new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, 1);
+            request.onerror = () => reject(request.error);
+            request.onupgradeneeded = () => request.result.createObjectStore(this.storeName);
+            request.onsuccess = () => {
+                const db = request.result;
+                const forget = () => {
+                    if (this.db === db)
+                        this.db = undefined;
+                };
+                db.onclose = forget;
+                db.onversionchange = () => {
+                    db.close();
+                    forget();
+                };
+                resolve(db);
+            };
         });
+        return this.db;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.3.6",
+    "version": "3.3.8",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {