http-request-manager 18.13.35 → 18.13.37

package/fesm2022/http-request-manager.mjs

@@ -5141,12 +5141,12 @@ class LocalStorageManagerService extends ComponentStore {
         this.storeExists$ = (store) => this.select(this.data$, (data) => data.settings.find(item => item.name === store) ? true : false);
         this.store$ = (store) => this.select(this.data$, (data) => {
             store = store.toLowerCase();
-            const foundStore = data.settings.find(item => item.name === store);
+            const foundStore = [...data.settings].reverse().find(item => item.name === store);
             if (foundStore) {
                 const options = SettingOptions.adapt(foundStore.options);
                 const found = foundStore.options?.storage === StorageType.GLOBAL
-                    ? data.localStores.find(item => item.id === foundStore.id)
-                    : data.sessionStores.find(item => item.id === foundStore.id);
+                    ? [...data.localStores].reverse().find(item => item.id === foundStore.id)
+                    : [...data.sessionStores].reverse().find(item => item.id === foundStore.id);
                 if (!found) {
                     console.warn('[CacheDebug] store$: settings entry found but no data entry in localStores/sessionStores', { store, foundStoreId: foundStore.id, storageType: foundStore.options?.storage });
                     this.deleteStore({ name: store });
@@ -5181,7 +5181,7 @@ class LocalStorageManagerService extends ComponentStore {
         });
         this.settings$ = this.select(state => (state) ? state.settings : storage.settings);
         this.setting$ = (store) => this.select(this.data$, (state) => {
-            const foundSetting = state.settings.find(item => item.name === store);
+            const foundSetting = [...state.settings].reverse().find(item => item.name === store);
             return (foundSetting) ? foundSetting : null;
         });
         this.persistence$ = this.data$
@@ -5208,11 +5208,14 @@ class LocalStorageManagerService extends ComponentStore {
                 const dataStr = (this.isObjectOrArray(str)) ? (store.options.encrypted) ? this.encryption.encrypt(str, this.app.appID) : store.data : store.data;
                 const localData = (dataStr && settings.options?.storage === StorageType.GLOBAL) ? [{ data: dataStr, id: settings.id }] : [];
                 const sessionData = (dataStr && settings.options?.storage === StorageType.SESSION) ? [{ data: dataStr, id: settings.id }] : [];
+                const localStores = state.localStores.filter(item => item.id !== settings.id);
+                const sessionStores = state.sessionStores.filter(item => item.id !== settings.id);
+                const stateSettings = state.settings.filter(item => item.id !== settings.id);
                 return {
                     ...state,
-                    localStores: [...state.localStores, ...localData],
-                    sessionStores: [...state.sessionStores, ...sessionData],
-                    settings: [...state.settings, ...[settings]],
+                    localStores: [...localStores, ...localData],
+                    sessionStores: [...sessionStores, ...sessionData],
+                    settings: [...stateSettings, ...[settings]],
                 };
             }
         });
@@ -5249,7 +5252,7 @@ class LocalStorageManagerService extends ComponentStore {
         this.updateStore = this.updater((state, store) => {
             store.name = store.name.toLowerCase();
             store.name = this.validStoreName(store.name);
-            const settings = state.settings.find(item => item.name === store.name);
+            const settings = [...state.settings].reverse().find(item => item.name === store.name);
             if (settings) {
                 const type = settings.options?.storage;
                 const hasStore = this.hasGlobalStorage(type, settings.id || '');
@@ -6099,7 +6102,7 @@ class DatabaseManagerService extends DbService {
                 console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
                 return EMPTY;
             }
-            const tableInstance = this.tables.find(t => t.name === tableName);
+            const tableInstance = this.getTable(tableName);
             if (!tableInstance) {
                 console.error(`createTableRecords: Table '${tableName}' does not exist in DB version ${this.verno}. Available:`, this.tables.map(t => t.name));
                 return EMPTY;
@@ -6107,17 +6110,49 @@ class DatabaseManagerService extends DbService {
             console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
             return from(tableInstance.bulkPut(insertRecords)).pipe(map(() => insertRecords));
         }));
+        const recreateMissingTableAndRetry = () => {
+            const inferredSchema = this.inferSchemaFromRecords(insertRecords);
+            if (!inferredSchema) {
+                console.warn(`createTableRecords: Could not infer schema for '${tableName}'. Retrying after DB reopen.`);
+                return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()));
+            }
+            const tableDef = TableSchemaDef.adapt({ table: tableName, schema: inferredSchema });
+            return this.createDatabaseTable(tableDef).pipe(switchMap((created) => {
+                if (!created) {
+                    console.warn(`createTableRecords: Failed to recreate table '${tableName}' from inferred schema. Retrying after DB reopen.`);
+                    return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()));
+                }
+                return writeRecords();
+            }));
+        };
         return writeRecords().pipe(catchError((error) => {
             if (!this.isMissingObjectStoreError(error)) {
                 throw error;
             }
-            console.warn(`createTableRecords: Missing object store for '${tableName}'. Waiting for DB readiness and retrying once...`, error);
-            return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()), catchError((retryError) => {
+            console.warn(`createTableRecords: Missing object store for '${tableName}'. Recreating table and retrying once...`, error);
+            return recreateMissingTableAndRetry().pipe(catchError((retryError) => {
                 console.error(`createTableRecords: Retry failed for '${tableName}'`, retryError);
                 throw retryError;
             }));
         }));
     }
+    inferSchemaFromRecords(records) {
+        if (!Array.isArray(records) || records.length === 0) {
+            return null;
+        }
+        const sample = records.find((record) => record && typeof record === 'object');
+        if (!sample) {
+            return null;
+        }
+        const fields = Object.keys(sample)
+            .filter((key) => key !== 'id')
+            .filter((key) => {
+            const value = sample[key];
+            return value === null || ['string', 'number', 'boolean'].includes(typeof value);
+        })
+            .sort();
+        return ['++id', ...fields].join(', ');
+    }
     isMissingObjectStoreError(error) {
         const name = String(error?.name || '').toLowerCase();
         const innerName = String(error?.inner?.name || '').toLowerCase();