@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/esm2022/src/app/core/services/storage/entities-storage.service.mjs

@@ -0,0 +1,427 @@
+import { defer, merge, timer } from 'rxjs';
+import { EventEmitter, Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { first, switchMap, throttleTime } from 'rxjs/operators';
+import { isEmptyArray, isNilOrBlank } from '../../../shared/functions';
+import { ENTITIES_STORAGE_KEY_PREFIX, EntityStore } from './entity-store.class';
+import { APP_PROGRESS_BAR_SERVICE } from '../../../shared/services/progress-bar.service';
+import { ENVIRONMENT } from '../../../../environments/environment.class';
+import { StartableService } from '../../../shared/services/startable-service.class';
+import { chainPromises } from '../../../shared/observables';
+import { APP_STORAGE } from '../../../shared/storage/storage.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "../../../../environments/environment.class";
+export const APP_LOCAL_STORAGE_TYPE_POLICIES = new InjectionToken('localStorageTypePolicies');
+export class EntitiesStorage extends StartableService {
+    platform;
+    storage;
+    environment;
+    progressBarService;
+    static TRASH_PREFIX = 'Trash#';
+    static REMOTE_PREFIX = 'Remote#';
+    _typePolicies;
+    _saveTimerPeriod;
+    _$save = new EventEmitter(true);
+    _dirty = false;
+    _saving = false;
+    get dirty() {
+        return this._dirty || Object.values(this._data).some((store) => store.dirty);
+    }
+    constructor(platform, storage, environment, progressBarService, typePolicies) {
+        super(storage);
+        this.platform = platform;
+        this.storage = storage;
+        this.environment = environment;
+        this.progressBarService = progressBarService;
+        this._typePolicies = typePolicies || {};
+        this._saveTimerPeriod = environment.storageSavePeriodMs || 10000 /* = 10s */;
+        this._data = {};
+        // For DEV only
+        this._debug = !environment.production;
+        if (this._debug)
+            console.debug('[entities-storage] Creating service');
+    }
+    async ngOnStart() {
+        const now = Date.now();
+        console.info(`[entities-storage] Starting entity storage...`);
+        // Restore stores
+        await this.restoreLocally();
+        // Start a save timer
+        this.registerSubscription(merge(this._$save, timer(this._saveTimerPeriod, this._saveTimerPeriod))
+            .pipe(
+        // Avoid to many call (e.g. when $save AND timer are triggered
+        throttleTime(this._saveTimerPeriod))
+            .subscribe(() => this.storeLocally({ skipIfPristine: true })));
+        // Save, when platform is in pause
+        this.registerSubscription(this.platform.pause.subscribe(async () => {
+            const now = Date.now();
+            console.info(`[entities-storage] Platform will pause: saving...`);
+            await this.storeLocally({ skipIfPristine: true });
+            console.info(`[entities-storage] Platform will pause: saving [OK] in ${Date.now() - now}ms`);
+        }));
+        console.info(`[entities-storage] Starting [OK] in ${Date.now() - now}ms`);
+        return this._data;
+    }
+    async ngOnStop() {
+        await this.storeLocally({ skipIfPristine: true });
+    }
+    watchAll(entityName, variables, opts) {
+        // Make sure store is ready
+        if (!this.started) {
+            return defer(() => this.ready()).pipe(switchMap(() => this.watchAll(entityName, variables, opts))); // Loop
+        }
+        this.progressBarService?.increase();
+        const storeName = variables && variables.trash ? EntitiesStorage.TRASH_PREFIX + entityName : entityName;
+        const result = this.getEntityStore(storeName, { create: true }).watchAll(variables, opts);
+        result.pipe(first()).subscribe(() => this.progressBarService?.decrease());
+        return result;
+    }
+    async loadAll(entityName, variables, opts) {
+        // Make sure store is ready
+        if (!this.started)
+            await this.ready();
+        try {
+            this.progressBarService?.increase();
+            if (this._debug)
+                console.debug(`[entities-storage] Loading ${entityName}...`);
+            const entityStore = this.getEntityStore(entityName, { create: false });
+            if (!entityStore)
+                return { data: [], total: 0 }; // No store for this entity name
+            return entityStore.loadAll(variables, opts);
+        }
+        finally {
+            this.progressBarService?.decrease();
+        }
+    }
+    async load(id, entityName, opts) {
+        await this.ready();
+        try {
+            this.progressBarService?.increase();
+            const entityStore = this.getEntityStore(entityName, { create: false });
+            if (!entityStore)
+                return undefined;
+            return await entityStore.load(id, opts);
+        }
+        finally {
+            this.progressBarService?.decrease();
+        }
+    }
+    async nextValue(entityOrName) {
+        await this.ready();
+        this._dirty = true;
+        return this.getEntityStore(this.detectEntityName(entityOrName)).nextValue();
+    }
+    async nextValues(entityOrName, entityCount) {
+        await this.ready();
+        this._dirty = true;
+        const entityName = this.detectEntityName(entityOrName);
+        const store = this.getEntityStore(entityName);
+        const firstValue = store.nextValue();
+        for (let i = 0; i < entityCount - 1; i++) {
+            store.nextValue();
+        }
+        if (this._debug)
+            console.debug(`[entities-storage] Reserving range [${firstValue},${store.currentValue()}] for ${entityName}'s sequence`);
+        return firstValue;
+    }
+    async currentValue(entityOrName) {
+        await this.ready();
+        return this.getEntityStore(this.detectEntityName(entityOrName)).currentValue();
+    }
+    async save(entity, opts) {
+        if (!entity)
+            return; // skip
+        if (!this.started)
+            await this.ready();
+        try {
+            this.progressBarService?.increase();
+            this._dirty = true;
+            const storeName = (opts && opts.entityName) || this.detectEntityName(entity);
+            this.getEntityStore(storeName).save(entity, opts);
+            // Ask to save
+            this._$save.emit();
+            return entity;
+        }
+        finally {
+            this.progressBarService?.decrease();
+        }
+    }
+    async saveAll(entities, opts) {
+        if (isEmptyArray(entities) && (!opts || opts.reset !== true))
+            return entities; // Skip (nothing to save)
+        if (!this.started)
+            await this.ready();
+        try {
+            this.progressBarService?.increase();
+            this._dirty = true;
+            const entityName = (opts && opts.entityName) || this.detectEntityName(entities[0]);
+            return this.getEntityStore(entityName).saveAll(entities, opts);
+        }
+        finally {
+            this.progressBarService?.decrease();
+        }
+    }
+    async delete(entity, opts) {
+        if (!entity)
+            return undefined; // skip
+        if (!this.started)
+            await this.ready();
+        return this.deleteById(entity.id, {
+            ...opts,
+            entityName: (opts && opts.entityName) || this.detectEntityName(entity),
+        });
+    }
+    async deleteById(id, opts) {
+        if (!this.started)
+            await this.ready();
+        if (!opts || isNilOrBlank(opts.entityName))
+            throw new Error("Missing argument 'opts' or 'entityName'");
+        //if (id >= 0) throw new Error('Invalid id a local entity (not a negative number): ' + id);
+        try {
+            this.progressBarService?.increase();
+            const entityStore = this.getEntityStore(opts.entityName, { create: false });
+            if (!entityStore)
+                return undefined;
+            const deletedEntity = entityStore.delete(id, opts);
+            // If something deleted
+            if (deletedEntity) {
+                // Mark as dirty
+                this._dirty = true;
+                // Ask to save
+                this._$save.emit();
+            }
+            return deletedEntity;
+        }
+        finally {
+            this.progressBarService?.decrease();
+        }
+    }
+    async deleteMany(ids, opts) {
+        if (!this.started)
+            await this.ready();
+        if (!opts || isNilOrBlank(opts.entityName))
+            throw new Error("Missing argument 'opts' or 'opts.entityName'");
+        try {
+            this.progressBarService?.increase();
+            const entityStore = this.getEntityStore(opts.entityName, { create: false });
+            if (!entityStore)
+                return undefined;
+            // Do deletion
+            const deletedEntities = entityStore.deleteMany(ids, opts);
+            // If something deleted
+            if (deletedEntities.length > 0) {
+                // Mark as dirty
+                this._dirty = true;
+                // Mark as saved need
+                this._$save.emit();
+            }
+            return deletedEntities;
+        }
+        finally {
+            this.progressBarService?.decrease();
+        }
+    }
+    async deleteFromTrash(entity, opts) {
+        if (!entity)
+            return undefined; // skip
+        if (!this.started)
+            await this.ready();
+        return this.deleteFromTrashById(entity.id, {
+            ...opts,
+            entityName: (opts && opts.entityName) || this.detectEntityName(entity),
+        });
+    }
+    async deleteFromTrashById(id, opts) {
+        await this.ready();
+        if (!opts || isNilOrBlank(opts.entityName))
+            throw new Error("Missing argument 'opts' or 'entityName'");
+        return this.deleteById(id, {
+            ...opts,
+            entityName: EntitiesStorage.TRASH_PREFIX + opts.entityName,
+        });
+    }
+    async moveToTrash(entity, opts) {
+        if (!entity)
+            return undefined; // skip
+        if (!this.started)
+            await this.ready();
+        const entityName = (opts && opts.entityName) || this.detectEntityName(entity);
+        // Delete entity by id, if exists
+        const entityStore = this.getEntityStore(entityName);
+        if (entityStore)
+            entityStore.delete(entity.id, opts);
+        // Clean id (a new id will be set by the trash store)
+        entity.id = undefined;
+        // Add to trash
+        const trashName = EntitiesStorage.TRASH_PREFIX + entityName;
+        this.getEntityStore(trashName).save(entity, opts);
+        this._$save.emit();
+        return entity;
+    }
+    async moveManyToTrash(ids, opts) {
+        if (!this.started)
+            await this.ready();
+        if (!opts || isNilOrBlank(opts.entityName))
+            throw new Error("Missing argument 'opts.entityName'");
+        const entityStore = this.getEntityStore(opts.entityName, { create: false });
+        if (!entityStore)
+            return undefined;
+        // Do deletion
+        const deletedEntities = entityStore.deleteMany(ids, opts);
+        // If something deleted
+        if (deletedEntities.length > 0) {
+            // Clean ids (new ids will be set by the trash store)
+            deletedEntities.forEach((e) => (e.id = undefined));
+            const trashName = EntitiesStorage.TRASH_PREFIX + opts.entityName;
+            this.getEntityStore(trashName, { create: true }).saveAll(deletedEntities, opts);
+            // Mark as dirty
+            this._dirty = true;
+            // Mark as save need
+            this._$save.emit();
+        }
+        return deletedEntities;
+    }
+    async saveToTrash(entity, opts) {
+        if (!entity)
+            return undefined; // skip
+        if (!this.started)
+            await this.ready();
+        const entityName = (opts && opts.entityName) || this.detectEntityName(entity);
+        const trashName = EntitiesStorage.TRASH_PREFIX + entityName;
+        this.getEntityStore(trashName).save(entity, opts);
+        this._$save.emit();
+        return entity;
+    }
+    async clearTrash(entityName) {
+        if (!this.started)
+            await this.ready();
+        const trashName = EntitiesStorage.TRASH_PREFIX + entityName;
+        const entityStore = this.getEntityStore(trashName, { create: false });
+        if (!entityStore)
+            return; // Skip
+        entityStore.reset();
+        this._dirty = true;
+        this._$save.emit();
+    }
+    persist(opts = { skipIfPristine: true }) {
+        return this.storeLocally(opts);
+    }
+    /* -- protected methods -- */
+    getEntityStore(name, opts) {
+        let store = this._data[name];
+        if (!store && (!opts || opts.create !== false)) {
+            if (this._debug)
+                console.debug(`[entities-storage] Creating store ${name}`);
+            const typePolicy = this._typePolicies[name];
+            store = new EntityStore(name, this.storage, typePolicy);
+            this._data[name] = store;
+        }
+        return store;
+    }
+    detectEntityName(entityOrName) {
+        if (!entityOrName)
+            throw Error('Unable to detect entityName of object: ' + entityOrName);
+        if (typeof entityOrName === 'string')
+            return entityOrName;
+        if (entityOrName.__typename) {
+            return entityOrName.__typename;
+        }
+        return entityOrName.constructor.name + 'VO';
+    }
+    async restoreLocally() {
+        const entityNames = await this.storage.get(ENTITIES_STORAGE_KEY_PREFIX);
+        if (!entityNames)
+            return;
+        const now = this._debug && Date.now();
+        if (this._debug)
+            console.info('[entities-storage] Restoring entities...');
+        const entitiesCount = (await Promise.all(entityNames.map((name) => this.getEntityStore(name)).map((store) => store.restore()))).reduce((res, count) => res + count, 0);
+        if (this._debug)
+            console.debug(`[entities-storage] Restoring entities [OK] ${entitiesCount} entities found in ${Date.now() - now}ms`);
+    }
+    async storeLocally(opts = { skipIfPristine: true }) {
+        if (opts.skipIfPristine && !this.dirty)
+            return; // skip
+        // Saving progress: report this save later
+        if (this._saving) {
+            if (this._debug)
+                console.debug('[entities-storage] Previous persist not finished. Waiting...');
+            this._$save.emit();
+            return;
+        }
+        this._saving = true;
+        this._dirty = false;
+        this.progressBarService?.increase();
+        const entityNames = (this._data && Object.keys(this._data)) || [];
+        const now = Date.now();
+        if (this._debug)
+            console.debug('[entities-storage] Persisting...');
+        let currentEntityName;
+        return chainPromises(entityNames.map((entityName) => () => {
+            currentEntityName = entityName;
+            const entityStore = this.getEntityStore(entityName, { create: false });
+            if (!entityStore) {
+                console.warn(`[entities-storage] Persisting ${entityName}: store not found!`);
+                return;
+            }
+            // SKip store if pristine
+            if (opts.skipIfPristine && !entityStore.dirty)
+                return Promise.resolve();
+            // Persist store
+            return entityStore.persist(opts).then((count) => {
+                // If no entity found, remove from the entity names array
+                if (!count) {
+                    const entityNameIndex = entityNames.findIndex((e) => e === entityName);
+                    if (entityNameIndex !== -1)
+                        entityNames.splice(entityNameIndex, 1);
+                }
+            });
+        }))
+            .then(() => {
+            currentEntityName = undefined;
+            return isEmptyArray(entityNames)
+                ? this.storage.remove(ENTITIES_STORAGE_KEY_PREFIX)
+                : this.storage.set(ENTITIES_STORAGE_KEY_PREFIX, entityNames);
+        })
+            .then(() => {
+            if (this._debug)
+                console.debug(`[entities-storage] Persisting [OK] ${entityNames.length} stores saved in ${Date.now() - now}ms...`);
+            this._saving = false;
+            this.progressBarService?.decrease();
+        })
+            .catch((err) => {
+            this._saving = false;
+            this.progressBarService?.decrease();
+            if (currentEntityName) {
+                console.error(`[entities-storage] Error while persisting ${currentEntityName}`, err);
+            }
+            else {
+                console.error(`[entities-storage] Error while persisting: ${(err && err.message) || err}`, err);
+            }
+            throw err;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EntitiesStorage, deps: [{ token: i1.Platform }, { token: APP_STORAGE }, { token: ENVIRONMENT }, { token: APP_PROGRESS_BAR_SERVICE, optional: true }, { token: APP_LOCAL_STORAGE_TYPE_POLICIES, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EntitiesStorage, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EntitiesStorage, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root', deps: [APP_STORAGE, ENVIRONMENT] }]
+        }], ctorParameters: () => [{ type: i1.Platform }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_STORAGE]
+                }] }, { type: i2.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_PROGRESS_BAR_SERVICE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_LOCAL_STORAGE_TYPE_POLICIES]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entities-storage.service.js","sourceRoot":"","sources":["../../../../../../../src/app/core/services/storage/entities-storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { defer, merge, Observable, timer } from 'rxjs';\nimport { EventEmitter, Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { Platform } from '@ionic/angular';\nimport { first, switchMap, throttleTime } from 'rxjs/operators';\nimport { Entity, IEntity } from '../model/entity.model';\nimport { isEmptyArray, isNilOrBlank } from '../../../shared/functions';\nimport { LoadResult } from '../../../shared/services/entity-service.class';\nimport { ENTITIES_STORAGE_KEY_PREFIX, EntityStorageLoadOptions, EntityStore, EntityStoreTypePolicy } from './entity-store.class';\nimport { APP_PROGRESS_BAR_SERVICE, IProgressBarService } from '../../../shared/services/progress-bar.service';\nimport { Environment, ENVIRONMENT } from '../../../../environments/environment.class';\nimport { StartableService } from '../../../shared/services/startable-service.class';\nimport { chainPromises } from '../../../shared/observables';\nimport { APP_STORAGE, IStorage } from '../../../shared/storage/storage.utils';\n\nexport interface EntitiesStorageTypePolicies {\n  [__typename: string]: EntityStoreTypePolicy;\n}\n\nexport const APP_LOCAL_STORAGE_TYPE_POLICIES = new InjectionToken<EntitiesStorageTypePolicies>('localStorageTypePolicies');\n\ndeclare interface EntityStorageMap {\n  [key: string]: EntityStore<any, any>;\n}\n\n@Injectable({ providedIn: 'root', deps: [APP_STORAGE, ENVIRONMENT] })\nexport class EntitiesStorage extends StartableService<EntityStorageMap> {\n  static readonly TRASH_PREFIX = 'Trash#';\n  static readonly REMOTE_PREFIX = 'Remote#';\n\n  private readonly _typePolicies: EntitiesStorageTypePolicies;\n  private readonly _saveTimerPeriod: number;\n\n  private _$save = new EventEmitter(true);\n  private _dirty = false;\n  private _saving = false;\n\n  get dirty(): boolean {\n    return this._dirty || Object.values(this._data).some((store) => store.dirty);\n  }\n\n  public constructor(\n    private platform: Platform,\n    @Inject(APP_STORAGE) private storage: IStorage,\n    @Inject(ENVIRONMENT) protected environment: Environment,\n    @Optional() @Inject(APP_PROGRESS_BAR_SERVICE) private progressBarService?: IProgressBarService,\n    @Optional() @Inject(APP_LOCAL_STORAGE_TYPE_POLICIES) typePolicies?: EntitiesStorageTypePolicies\n  ) {\n    super(storage);\n    this._typePolicies = typePolicies || {};\n    this._saveTimerPeriod = environment.storageSavePeriodMs || 10000 /* = 10s */;\n    this._data = {};\n\n    // For DEV only\n    this._debug = !environment.production;\n    if (this._debug) console.debug('[entities-storage] Creating service');\n  }\n\n  async ngOnStart(): Promise<EntityStorageMap> {\n    const now = Date.now();\n    console.info(`[entities-storage] Starting entity storage...`);\n\n    // Restore stores\n    await this.restoreLocally();\n\n    // Start a save timer\n    this.registerSubscription(\n      merge(this._$save, timer(this._saveTimerPeriod, this._saveTimerPeriod))\n        .pipe(\n          // Avoid to many call (e.g. when $save AND timer are triggered\n          throttleTime(this._saveTimerPeriod)\n        )\n        .subscribe(() => this.storeLocally({ skipIfPristine: true }))\n    );\n\n    // Save, when platform is in pause\n    this.registerSubscription(\n      this.platform.pause.subscribe(async () => {\n        const now = Date.now();\n        console.info(`[entities-storage] Platform will pause: saving...`);\n        await this.storeLocally({ skipIfPristine: true });\n        console.info(`[entities-storage] Platform will pause: saving [OK] in ${Date.now() - now}ms`);\n      })\n    );\n\n    console.info(`[entities-storage] Starting [OK] in ${Date.now() - now}ms`);\n\n    return this._data;\n  }\n\n  protected async ngOnStop() {\n    await this.storeLocally({ skipIfPristine: true });\n  }\n\n  watchAll<T extends Entity<T>>(\n    entityName: string,\n    variables: {\n      offset?: number;\n      size?: number;\n      sortBy?: keyof T | string;\n      sortDirection?: string;\n      trash?: boolean;\n      filter?: (data: T) => boolean;\n    },\n    opts?: EntityStorageLoadOptions\n  ): Observable<LoadResult<T>> {\n    // Make sure store is ready\n    if (!this.started) {\n      return defer(() => this.ready()).pipe(switchMap(() => this.watchAll<T>(entityName, variables, opts))); // Loop\n    }\n\n    this.progressBarService?.increase();\n    const storeName = variables && variables.trash ? EntitiesStorage.TRASH_PREFIX + entityName : entityName;\n    const result = this.getEntityStore<T>(storeName, { create: true }).watchAll(variables, opts);\n\n    result.pipe(first()).subscribe(() => this.progressBarService?.decrease());\n\n    return result;\n  }\n\n  async loadAll<T extends Entity<T>>(\n    entityName: string,\n    variables?: {\n      offset?: number;\n      size?: number;\n      sortBy?: keyof T | string;\n      sortDirection?: string;\n      filter?: (data: T) => boolean;\n    },\n    opts?: EntityStorageLoadOptions\n  ): Promise<LoadResult<T>> {\n    // Make sure store is ready\n    if (!this.started) await this.ready();\n\n    try {\n      this.progressBarService?.increase();\n      if (this._debug) console.debug(`[entities-storage] Loading ${entityName}...`);\n\n      const entityStore = this.getEntityStore<T>(entityName, { create: false });\n      if (!entityStore) return { data: [], total: 0 }; // No store for this entity name\n\n      return entityStore.loadAll(variables, opts);\n    } finally {\n      this.progressBarService?.decrease();\n    }\n  }\n\n  async load<T extends Entity<T>>(id: number, entityName: string, opts?: EntityStorageLoadOptions): Promise<T> {\n    await this.ready();\n\n    try {\n      this.progressBarService?.increase();\n\n      const entityStore = this.getEntityStore<T>(entityName, { create: false });\n      if (!entityStore) return undefined;\n      return await entityStore.load(id, opts);\n    } finally {\n      this.progressBarService?.decrease();\n    }\n  }\n\n  async nextValue(entityOrName: string | any): Promise<number> {\n    await this.ready();\n    this._dirty = true;\n    return this.getEntityStore(this.detectEntityName(entityOrName)).nextValue();\n  }\n\n  async nextValues(entityOrName: string | any, entityCount: number): Promise<number> {\n    await this.ready();\n    this._dirty = true;\n    const entityName = this.detectEntityName(entityOrName);\n    const store = this.getEntityStore(entityName);\n    const firstValue = store.nextValue();\n    for (let i = 0; i < entityCount - 1; i++) {\n      store.nextValue();\n    }\n    if (this._debug) console.debug(`[entities-storage] Reserving range [${firstValue},${store.currentValue()}] for ${entityName}'s sequence`);\n    return firstValue;\n  }\n\n  async currentValue(entityOrName: string | any): Promise<number> {\n    await this.ready();\n    return this.getEntityStore(this.detectEntityName(entityOrName)).currentValue();\n  }\n\n  async save<T extends Entity<T>>(\n    entity: T,\n    opts?: {\n      entityName?: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T> {\n    if (!entity) return; // skip\n\n    if (!this.started) await this.ready();\n\n    try {\n      this.progressBarService?.increase();\n\n      this._dirty = true;\n      const storeName = (opts && opts.entityName) || this.detectEntityName(entity);\n      this.getEntityStore<T>(storeName).save(entity, opts);\n\n      // Ask to save\n      this._$save.emit();\n\n      return entity;\n    } finally {\n      this.progressBarService?.decrease();\n    }\n  }\n\n  async saveAll<T extends Entity<T>>(\n    entities: T[],\n    opts?: {\n      entityName?: string;\n      reset?: boolean;\n      emitEvent?: boolean;\n    }\n  ): Promise<T[]> {\n    if (isEmptyArray(entities) && (!opts || opts.reset !== true)) return entities; // Skip (nothing to save)\n\n    if (!this.started) await this.ready();\n\n    try {\n      this.progressBarService?.increase();\n\n      this._dirty = true;\n      const entityName = (opts && opts.entityName) || this.detectEntityName(entities[0]);\n      return this.getEntityStore<T>(entityName).saveAll(entities, opts);\n    } finally {\n      this.progressBarService?.decrease();\n    }\n  }\n\n  async delete<T extends Entity<T, ID>, ID = number>(\n    entity: T,\n    opts?: {\n      entityName?: string;\n    }\n  ): Promise<T> {\n    if (!entity) return undefined; // skip\n\n    if (!this.started) await this.ready();\n\n    return this.deleteById(entity.id, {\n      ...opts,\n      entityName: (opts && opts.entityName) || this.detectEntityName(entity),\n    });\n  }\n\n  async deleteById<T extends IEntity<T, ID>, ID = number>(\n    id: ID,\n    opts: {\n      entityName: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T> {\n    if (!this.started) await this.ready();\n\n    if (!opts || isNilOrBlank(opts.entityName)) throw new Error(\"Missing argument 'opts' or 'entityName'\");\n    //if (id >= 0) throw new Error('Invalid id a local entity (not a negative number): ' + id);\n\n    try {\n      this.progressBarService?.increase();\n      const entityStore = this.getEntityStore<T, ID>(opts.entityName, { create: false });\n      if (!entityStore) return undefined;\n\n      const deletedEntity = entityStore.delete(id, opts);\n\n      // If something deleted\n      if (deletedEntity) {\n        // Mark as dirty\n        this._dirty = true;\n\n        // Ask to save\n        this._$save.emit();\n      }\n\n      return deletedEntity;\n    } finally {\n      this.progressBarService?.decrease();\n    }\n  }\n\n  async deleteMany<T extends Entity<T>>(\n    ids: number[],\n    opts: {\n      entityName: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T[]> {\n    if (!this.started) await this.ready();\n\n    if (!opts || isNilOrBlank(opts.entityName)) throw new Error(\"Missing argument 'opts' or 'opts.entityName'\");\n\n    try {\n      this.progressBarService?.increase();\n      const entityStore = this.getEntityStore<T>(opts.entityName, { create: false });\n      if (!entityStore) return undefined;\n\n      // Do deletion\n      const deletedEntities = entityStore.deleteMany(ids, opts);\n\n      // If something deleted\n      if (deletedEntities.length > 0) {\n        // Mark as dirty\n        this._dirty = true;\n\n        // Mark as saved need\n        this._$save.emit();\n      }\n\n      return deletedEntities;\n    } finally {\n      this.progressBarService?.decrease();\n    }\n  }\n\n  async deleteFromTrash<T extends Entity<T>>(\n    entity: T,\n    opts?: {\n      entityName?: string;\n    }\n  ): Promise<T> {\n    if (!entity) return undefined; // skip\n\n    if (!this.started) await this.ready();\n\n    return this.deleteFromTrashById(entity.id, {\n      ...opts,\n      entityName: (opts && opts.entityName) || this.detectEntityName(entity),\n    });\n  }\n\n  async deleteFromTrashById<T extends Entity<T>>(\n    id: number,\n    opts: {\n      entityName: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T> {\n    await this.ready();\n\n    if (!opts || isNilOrBlank(opts.entityName)) throw new Error(\"Missing argument 'opts' or 'entityName'\");\n\n    return this.deleteById(id, {\n      ...opts,\n      entityName: EntitiesStorage.TRASH_PREFIX + opts.entityName,\n    });\n  }\n\n  async moveToTrash<T extends Entity<T>>(\n    entity: T,\n    opts?: {\n      entityName?: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T> {\n    if (!entity) return undefined; // skip\n\n    if (!this.started) await this.ready();\n\n    const entityName = (opts && opts.entityName) || this.detectEntityName(entity);\n\n    // Delete entity by id, if exists\n    const entityStore = this.getEntityStore<T>(entityName);\n    if (entityStore) entityStore.delete(entity.id, opts);\n\n    // Clean id (a new id will be set by the trash store)\n    entity.id = undefined;\n\n    // Add to trash\n    const trashName = EntitiesStorage.TRASH_PREFIX + entityName;\n    this.getEntityStore<T>(trashName).save(entity, opts);\n\n    this._$save.emit();\n\n    return entity;\n  }\n\n  async moveManyToTrash<T extends Entity<T>>(\n    ids: number[],\n    opts: {\n      entityName: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T[]> {\n    if (!this.started) await this.ready();\n\n    if (!opts || isNilOrBlank(opts.entityName)) throw new Error(\"Missing argument 'opts.entityName'\");\n\n    const entityStore = this.getEntityStore<T>(opts.entityName, { create: false });\n    if (!entityStore) return undefined;\n\n    // Do deletion\n    const deletedEntities = entityStore.deleteMany(ids, opts);\n\n    // If something deleted\n    if (deletedEntities.length > 0) {\n      // Clean ids (new ids will be set by the trash store)\n      deletedEntities.forEach((e) => (e.id = undefined));\n\n      const trashName = EntitiesStorage.TRASH_PREFIX + opts.entityName;\n      this.getEntityStore<T>(trashName, { create: true }).saveAll(deletedEntities, opts);\n\n      // Mark as dirty\n      this._dirty = true;\n\n      // Mark as save need\n      this._$save.emit();\n    }\n\n    return deletedEntities;\n  }\n\n  async saveToTrash<T extends Entity<T>>(\n    entity: T,\n    opts?: {\n      entityName?: string;\n      emitEvent?: boolean;\n    }\n  ): Promise<T> {\n    if (!entity) return undefined; // skip\n\n    if (!this.started) await this.ready();\n\n    const entityName = (opts && opts.entityName) || this.detectEntityName(entity);\n    const trashName = EntitiesStorage.TRASH_PREFIX + entityName;\n    this.getEntityStore<T>(trashName).save(entity, opts);\n\n    this._$save.emit();\n\n    return entity;\n  }\n\n  async clearTrash(entityName: string) {\n    if (!this.started) await this.ready();\n\n    const trashName = EntitiesStorage.TRASH_PREFIX + entityName;\n    const entityStore = this.getEntityStore(trashName, { create: false });\n    if (!entityStore) return; // Skip\n\n    entityStore.reset();\n    this._dirty = true;\n\n    this._$save.emit();\n  }\n\n  persist(opts = { skipIfPristine: true }): Promise<void> {\n    return this.storeLocally(opts);\n  }\n\n  /* -- protected methods -- */\n\n  protected getEntityStore<T extends IEntity<T, ID>, ID = number>(\n    name: string,\n    opts?: {\n      create?: boolean;\n    }\n  ): EntityStore<T, ID> {\n    let store = this._data[name];\n    if (!store && (!opts || opts.create !== false)) {\n      if (this._debug) console.debug(`[entities-storage] Creating store ${name}`);\n      const typePolicy = this._typePolicies[name];\n      store = new EntityStore<T, ID>(name, this.storage, typePolicy);\n      this._data[name] = store;\n    }\n    return store;\n  }\n\n  protected detectEntityName(entityOrName: string | Entity<any, any>): string {\n    if (!entityOrName) throw Error('Unable to detect entityName of object: ' + entityOrName);\n    if (typeof entityOrName === 'string') return entityOrName;\n    if (entityOrName.__typename) {\n      return entityOrName.__typename;\n    }\n    return entityOrName.constructor.name + 'VO';\n  }\n\n  protected async restoreLocally() {\n    const entityNames = await this.storage.get(ENTITIES_STORAGE_KEY_PREFIX);\n    if (!entityNames) return;\n\n    const now = this._debug && Date.now();\n    if (this._debug) console.info('[entities-storage] Restoring entities...');\n    const entitiesCount = (\n      await Promise.all<number>(entityNames.map((name) => this.getEntityStore<any>(name)).map((store: EntityStore<any>) => store.restore()))\n    ).reduce((res, count) => res + count, 0);\n\n    if (this._debug) console.debug(`[entities-storage] Restoring entities [OK] ${entitiesCount} entities found in ${Date.now() - now}ms`);\n  }\n\n  protected async storeLocally(opts = { skipIfPristine: true }): Promise<void> {\n    if (opts.skipIfPristine && !this.dirty) return; // skip\n\n    // Saving progress: report this save later\n    if (this._saving) {\n      if (this._debug) console.debug('[entities-storage] Previous persist not finished. Waiting...');\n      this._$save.emit();\n      return;\n    }\n\n    this._saving = true;\n    this._dirty = false;\n    this.progressBarService?.increase();\n    const entityNames = (this._data && Object.keys(this._data)) || [];\n\n    const now = Date.now();\n    if (this._debug) console.debug('[entities-storage] Persisting...');\n\n    let currentEntityName;\n    return chainPromises(\n      entityNames.map((entityName) => () => {\n        currentEntityName = entityName;\n        const entityStore = this.getEntityStore(entityName, { create: false });\n\n        if (!entityStore) {\n          console.warn(`[entities-storage] Persisting ${entityName}: store not found!`);\n          return;\n        }\n\n        // SKip store if pristine\n        if (opts.skipIfPristine && !entityStore.dirty) return Promise.resolve();\n\n        // Persist store\n        return entityStore.persist(opts).then((count) => {\n          // If no entity found, remove from the entity names array\n          if (!count) {\n            const entityNameIndex = entityNames.findIndex((e) => e === entityName);\n            if (entityNameIndex !== -1) entityNames.splice(entityNameIndex, 1);\n          }\n        });\n      })\n    )\n      .then(() => {\n        currentEntityName = undefined;\n        return isEmptyArray(entityNames)\n          ? this.storage.remove(ENTITIES_STORAGE_KEY_PREFIX)\n          : this.storage.set(ENTITIES_STORAGE_KEY_PREFIX, entityNames);\n      })\n      .then(() => {\n        if (this._debug) console.debug(`[entities-storage] Persisting [OK] ${entityNames.length} stores saved in ${Date.now() - now}ms...`);\n        this._saving = false;\n        this.progressBarService?.decrease();\n      })\n      .catch((err) => {\n        this._saving = false;\n        this.progressBarService?.decrease();\n        if (currentEntityName) {\n          console.error(`[entities-storage] Error while persisting ${currentEntityName}`, err);\n        } else {\n          console.error(`[entities-storage] Error while persisting: ${(err && err.message) || err}`, err);\n        }\n        throw err;\n      });\n  }\n}\n"]}