add clone processing in addPersistent

Author: bunin-av

src/core/cache/decorators/persistent/CHANGELOG.md

@@ -15,6 +15,10 @@ Changelog
 
 * Change type parameters from `<V, K>` to `<K, V>`
 
+####  :rocket: New Feature
+
+* Added a new method `clone` processing
+
 ## v3.60.2 (2021-10-04)
 
 #### :bug: Bug Fix

src/core/cache/decorators/persistent/engines/active.ts

@@ -13,10 +13,6 @@ import { INDEX_STORAGE_NAME } from 'core/cache/decorators/persistent/engines/con
 import { UncheckablePersistentEngine } from 'core/cache/decorators/persistent/engines/interface';
 
 export default class ActivePersistentEngine<V> extends UncheckablePersistentEngine<V> {
-	/**
-	 * Index with keys and TTL-s of stored values
-	 */
-	protected ttlIndex: Dictionary<number> = Object.createDict();
 
 	override async initCache(cache: Cache<string, V>): Promise<void> {
 		if (await this.storage.has(INDEX_STORAGE_NAME)) {

src/core/cache/decorators/persistent/engines/interface.ts

@@ -20,6 +20,11 @@ export interface AbstractPersistentEngine<V = unknown> {
 }
 
 export abstract class AbstractPersistentEngine<V = unknown> {
+	/**
+	 * Index with keys and TTL-s of stored values
+	 */
+	ttlIndex: Dictionary<number> = Object.createDict();
+
 	/**
 	 * API for async operations
 	 */

src/core/cache/decorators/persistent/engines/lazy.ts

@@ -23,8 +23,11 @@ export default class LazyPersistentEngine<V> extends CheckablePersistentEngine<V
 
 			} finally {
 				if (ttl != null) {
-					await this.storage.set(key + TTL_POSTFIX, this.normalizeTTL(ttl));
+					const
+						normalizedTTL = this.normalizeTTL(ttl);
 
+					await this.storage.set(key + TTL_POSTFIX, normalizedTTL);
+					this.ttlIndex[key] = normalizedTTL;
 				} else {
 					await this.removeTTLFrom(key);
 				}

src/core/cache/decorators/persistent/interface.ts

@@ -6,6 +6,7 @@
  * https://github.com/V4Fire/Core/blob/master/LICENSE
  */
 
+import type { AsyncStorageNamespace, SyncStorageNamespace } from 'core/kv-storage';
 import type { CacheWithEmitter } from 'core/cache/decorators/helpers/add-emitter/interface';
 import type { eventEmitter } from 'core/cache/decorators/helpers/add-emitter';
 
@@ -35,6 +36,8 @@ export type PersistentCache<K = string, V = unknown, T extends CacheWithEmitter<
 
 	/** @see [[CacheWithEmitter[eventEmitterSymbol]]] */
 	eventEmitter: T[typeof eventEmitter];
+
+	cloneTo(storage: SyncStorageNamespace | AsyncStorageNamespace): Promise<PersistentCache<K, V>>;
 };
 
 export interface PersistentTTLDecoratorOptions {

src/core/cache/decorators/persistent/spec.js

@@ -7,7 +7,7 @@
  */
 
 import * as netModule from 'core/net';
-import { asyncLocal } from 'core/kv-storage';
+import { asyncLocal, asyncSession } from 'core/kv-storage';
 
 import addPersistent from 'core/cache/decorators/persistent';
 
@@ -80,6 +80,39 @@ describe('core/cache/decorators/persistent', () => {
 			expect(await asyncLocal.get(INDEX_STORAGE_NAME)).toEqual({bar: Number.MAX_SAFE_INTEGER});
 		});
 
+		it('should clone the cache', async () => {
+			const opts = {
+				loadFromStorage: 'onInit'
+			};
+
+			const
+				persistentCache = await addPersistent(new SimpleCache(), asyncLocal, opts);
+
+			await persistentCache.set('foo', 1, {persistentTTL: 100});
+			await persistentCache.set('bar', 1, {persistentTTL: 10});
+
+			const
+				fakeClonedCache = persistentCache.clone(),
+				clonedCache = await persistentCache.cloneTo(asyncSession);
+
+			expect(fakeClonedCache).toBe(undefined);
+			expect(await clonedCache.get('foo')).toBe(1);
+			expect(await clonedCache.get('bar')).toBe(1);
+
+			expect(await asyncLocal.get(INDEX_STORAGE_NAME)).toEqual({foo: 100, bar: 10});
+			expect(await asyncSession.get(INDEX_STORAGE_NAME)).toEqual({foo: 100, bar: 10});
+
+			Date.now = () => 50;
+
+			const
+				persistentCache2 = await addPersistent(new SimpleCache(), asyncSession, opts);
+
+			expect(await persistentCache2.get('foo')).toBe(1);
+			expect(await persistentCache2.get('bar')).toBe(undefined);
+
+			Date.now = () => 0;
+		});
+
 		it('`clear` caused by a side effect', async () => {
 			const opts = {
 				loadFromStorage: 'onInit'

src/core/cache/decorators/persistent/wrapper.ts

@@ -7,6 +7,7 @@
  */
 
 import SyncPromise from 'core/promise/sync';
+import { unimplement } from 'core/functools';
 import type { SyncStorageNamespace, AsyncStorageNamespace } from 'core/kv-storage';
 
 import type Cache from 'core/cache/interface';
@@ -44,6 +45,11 @@ export default class PersistentWrapper<T extends Cache<string, V>, V = unknown>
 	 */
 	protected readonly fetchedItems: Set<string> = new Set();
 
+	/**
+	 * Object with incom
+	 */
+	protected readonly opts?: PersistentOptions;
+
 	/**
 	 * @param cache - cache object to wrap
 	 * @param storage - storage object to save cache items
@@ -54,6 +60,7 @@ export default class PersistentWrapper<T extends Cache<string, V>, V = unknown>
 
 		this.cache = cache;
 		this.wrappedCache = Object.create(cache);
+		this.opts = opts;
 
 		this.engine = new engines[opts?.loadFromStorage ?? 'onDemand']<V>(storage);
 	}
@@ -82,47 +89,115 @@ export default class PersistentWrapper<T extends Cache<string, V>, V = unknown>
 			subscribe
 		} = addEmitter<T, string, V>(this.cache);
 
-		this.wrappedCache.has = this.getDefaultImplementation('has');
-		this.wrappedCache.get = this.getDefaultImplementation('get');
-
-		this.wrappedCache.set = async (key: string, value: V, opts?: PersistentTTLDecoratorOptions & Parameters<T['set']>[2]) => {
-			const
-				ttl = opts?.persistentTTL ?? this.ttl;
-
-			this.fetchedItems.add(key);
-
-			const
-				res = originalSet(key, value, opts);
+		const descriptor = {
+			enumerable: false,
+			writable: true,
+			configurable: true
+		};
 
-			if (this.cache.has(key)) {
-				await this.engine.set(key, value, ttl);
-			}
+		Object.defineProperties(this.wrappedCache, {
+			has: {
+				value: this.getDefaultImplementation('has'),
+				...descriptor
+			},
 
-			return res;
-		};
+			get: {
+				value: this.getDefaultImplementation('get'),
+				...descriptor
+			},
 
-		this.wrappedCache.remove = async (key: string) => {
-			this.fetchedItems.add(key);
-			await this.engine.remove(key);
-			return originalRemove(key);
-		};
+			set: {
+				value: async (key: string, value: V, opts?: PersistentTTLDecoratorOptions & Parameters<T['set']>[2]) => {
+					const
+						ttl = opts?.persistentTTL ?? this.ttl;
 
-		this.wrappedCache.keys = () => SyncPromise.resolve(this.cache.keys());
+					this.fetchedItems.add(key);
 
-		this.wrappedCache.clear = async (filter?: ClearFilter<V>) => {
-			const
-				removed = originalClear(filter),
-				removedKeys: string[] = [];
+					const
+						res = originalSet(key, value, opts);
 
-			removed.forEach((_, key) => {
-				removedKeys.push(key);
-			});
+					if (this.cache.has(key)) {
+						await this.engine.set(key, value, ttl);
+					}
 
-			await Promise.allSettled(removedKeys.map((key) => this.engine.remove(key)));
-			return removed;
-		};
+					return res;
+				},
+				...descriptor
+			},
 
-		this.wrappedCache.removePersistentTTLFrom = (key) => this.engine.removeTTLFrom(key);
+			remove: {
+				value: async (key: string) => {
+					this.fetchedItems.add(key);
+					await this.engine.remove(key);
+					return originalRemove(key);
+				},
+				...descriptor
+			},
+
+			keys: {
+				value: () => SyncPromise.resolve(this.cache.keys()),
+				...descriptor
+			},
+
+			clear: {
+				value: async (filter?: ClearFilter<V>) => {
+					const
+						removed = originalClear(filter),
+						removedKeys: string[] = [];
+
+					removed.forEach((_, key) => {
+						removedKeys.push(key);
+					});
+
+					await Promise.allSettled(removedKeys.map((key) => this.engine.remove(key)));
+					return removed;
+				},
+				...descriptor
+			},
+
+			clone: {
+				value: () => {
+					unimplement({
+						type: 'function',
+						alternative: {name: 'cloneTo'}
+					}, this.wrappedCache.clone);
+				},
+				...descriptor
+			},
+
+			cloneTo: {
+				value: async (
+					storage: SyncStorageNamespace | AsyncStorageNamespace
+				): Promise<PersistentCache<string, V>> => {
+					const
+						cache = new PersistentWrapper<Cache<string, V>, V>(this.cache.clone(), storage, {...this.opts});
+
+					Object.defineProperties(cache, {
+						fetchedItems: {
+							value: new Set(this.fetchedItems)
+						}
+					});
+
+					for (const [key, value] of this.cache.entries()) {
+						const
+							ttl = this.engine.ttlIndex[key] ?? 0,
+							time = Date.now();
+
+						if (ttl > time) {
+							await cache.engine.set(key, value, ttl - time);
+						}
+					}
+
+					return cache.getInstance();
+				},
+				...descriptor
+			},
+
+			removePersistentTTLFrom: {
+				value: (key) => this.engine.removeTTLFrom(key),
+				...descriptor
+			}
+		});
 
 		subscribe('remove', this.wrappedCache, ({args}) =>
 			this.engine.remove(args[0]));
@@ -135,6 +210,8 @@ export default class PersistentWrapper<T extends Cache<string, V>, V = unknown>
 		subscribe('clear', this.wrappedCache, ({result}) => {
 			result.forEach((_, key) => this.engine.remove(key));
 		});
+
+		subscribe('clone', this.wrappedCache, () => this.wrappedCache.clone());
 	}
 
 	/**