Remove ProfileManager

packages/core/src/Modules/CoreModule.ts

@@ -1,9 +1,11 @@
-import { IKeyValueStoreSymbol, IObjectStoreSymbol } from 'ipmc-interfaces';
+import { IIndexManagerSymbol, IKeyValueStoreSymbol, IObjectStoreSymbol } from 'ipmc-interfaces';
 import { MemoryKeyValueStore } from '../Services/MemoryKeyValueStore';
 import { ObjectStore } from '../Services/ObjectStore';
 import { IModule } from './IModule';
+import { IndexManager } from '../Services/IndexManager';
 
 export const CoreModule: IModule = (app) => {
 	app.register(MemoryKeyValueStore, IKeyValueStoreSymbol);
 	app.register(ObjectStore, IObjectStoreSymbol);
+	app.register(IndexManager, IIndexManagerSymbol);
 };

packages/core/src/Services/IndexManager.ts

@@ -0,0 +1,92 @@
+import { Signal } from '@preact/signals-core';
+import { inject, injectable, postConstruct, preDestroy } from 'inversify';
+import { IIndexManager, IIpfsService, IIpfsServiceSymbol, ILibrary, ILibraryIndex, IObjectStore, IObjectStoreSymbol, IProfile, IProfileSymbol, ITask, isMovieLibrary, isSeriesLibrary } from 'ipmc-interfaces';
+import { MovieIndexFetcher, SeriesIndexFetcher } from './Indexer';
+
+@injectable()
+export class IndexManager implements IIndexManager {
+	public constructor(
+		@inject(IProfileSymbol) private readonly profile: IProfile,
+		@inject(IIpfsServiceSymbol) private readonly ipfs: IIpfsService,
+		@inject(IObjectStoreSymbol) private readonly objectStore: IObjectStore,
+	) {
+		for (const lib of this.profile.libraries) {
+			this.libraries.set(lib.name, new Signal<ILibrary>(lib));
+			const indexSignal = new Signal<ILibraryIndex<any> | undefined>(this.objectStore.get(this.getIndexStorageKey(lib.name)));
+			this.indexes.set(lib.name, indexSignal);
+			indexSignal.subscribe((newState) => {
+				if (newState !== undefined) {
+					this.objectStore.set(this.getIndexStorageKey(lib.name), newState);
+				}
+			});
+		}
+	}
+
+	@postConstruct()
+	public start(): void {
+		this.triggerUpdate();
+		this.timer = setInterval(() => {
+			this.triggerUpdate();
+		}, 15 * 60 * 1000);
+	}
+
+	@preDestroy()
+	public stop(): void {
+		clearInterval(this.timer);
+	}
+
+	public indexes = new Map<string, Signal<ILibraryIndex<any> | undefined>>();
+
+	public tasks = new Signal<ITask[]>([]);
+
+	private getIndexStorageKey(name: string) {
+		return `${this.profile.id}_index_${name}`;
+	}
+
+	private triggerUpdate(): void {
+		for (const library of this.libraries.values()) {
+			const lib = library.value;
+			if (!this.updates.has(lib.name)) {
+				const task = {
+					title: 'Updating library ' + lib.name,
+				};
+				this.tasks.value = [...this.tasks.value, task];
+				this.updates.set(lib.name, this.updateLibrary(lib).finally(() => {
+					this.updates.delete(lib.name);
+					this.tasks.value = this.tasks.value.filter(t => t != task);
+				}));
+			}
+		}
+	}
+
+	private async updateLibrary(library: ILibrary): Promise<void> {
+		const index = this.indexes.get(library.name);
+		if (library.upstream != undefined && index != undefined) {
+			try {
+				const cid = await this.ipfs.resolve(library.upstream);
+				const indexer = isMovieLibrary(library) ? new MovieIndexFetcher(this.ipfs, library) : isSeriesLibrary(library) ? new SeriesIndexFetcher(this.ipfs, library) : undefined;
+				if (index.value?.cid != cid || indexer?.version !== index.value?.indexer) {
+					if (indexer == undefined) {
+						throw new Error(`Unknown library type [${library.type}]`);
+					}
+
+					const newIndex = await indexer.fetchIndex();
+
+					index.value = {
+						cid: cid,
+						indexer: indexer.version,
+						index: newIndex,
+					};
+				}
+			} catch (ex) {
+				console.error(ex);
+			}
+		}
+	}
+
+	private libraries = new Map<string, Signal<ILibrary>>();
+
+	private updates = new Map<string, Promise<void>>();
+
+	private timer: any;
+}

packages/core/src/Services/Indexer/IIndexFetcher.ts

@@ -1,3 +1,4 @@
 export interface IIndexFetcher<TIndex> {
 	fetchIndex(): Promise<TIndex>;
+	version: string;
 }

packages/core/src/Services/Indexer/MovieIndexFetcher.ts

@@ -6,6 +6,8 @@ export class MovieIndexFetcher implements IIndexFetcher<IMovieMetaData[]> {
 	constructor(private readonly node: IIpfsService, private readonly lib: IGenericLibrary<IMovieMetaData, 'movie'>) {
 	}
 
+	public version = '0';
+
 	public async fetchIndex(): Promise<IMovieMetaData[]> {
 		const files = (await this.node.ls(this.lib.root.toString())).filter(f => f.type == 'dir');
 		const index = [];

packages/core/src/Services/Indexer/SeriesIndexFetcher.ts

@@ -6,6 +6,8 @@ export class SeriesIndexFetcher implements IIndexFetcher<ISeriesMetaData[]> {
 	constructor(private readonly node: IIpfsService, private readonly lib: IGenericLibrary<ISeriesMetaData, 'series'>) {
 	}
 
+	public version = '0';
+
 	public async fetchIndex(): Promise<ISeriesMetaData[]> {
 		const files = (await this.node.ls(this.lib.root.toString())).filter(f => f.type == 'dir');
 		const index = [];

packages/core/src/Services/Indexer/index.ts

@@ -1,2 +1,3 @@
+export { type IIndexFetcher } from './IIndexFetcher';
 export { MovieIndexFetcher } from './MovieIndexFetcher';
 export { SeriesIndexFetcher } from './SeriesIndexFetcher';

packages/core/src/Services/index.ts

@@ -1,5 +1,4 @@
 export * from './Indexer';
-export * from './ProfileManager';
 export { HotkeyService } from './HotkeyService';
 export { LocalStorageKeyValueStore } from './LocalStorageKeyValueStore';
 export { MemoryKeyValueStore } from './MemoryKeyValueStore';

packages/core/src/index.ts

@@ -2,6 +2,7 @@ import 'reflect-metadata';
 
 export * from './Modules';
 export * from './Services';
+export * from './util';
 export { Application } from './Application';
 export { type IApplication } from './IApplication';
 export { Regexes } from './Regexes';