Extract settings from database

frontend/sync-client/src/persistence/database.ts

@@ -0,0 +1,130 @@
+export type VaultUpdateId = number;
+export type DocumentId = string;
+export type RelativePath = string;
+
+export interface DocumentMetadata {
+	parentVersionId: VaultUpdateId;
+	documentId: DocumentId;
+	hash: string;
+}
+
+import { Logger } from "src/tracing/logger";
+
+export interface StoredDatabase {
+	documents: Map<RelativePath, DocumentMetadata>;
+	lastSeenUpdateId: VaultUpdateId | undefined;
+}
+
+export class Database {
+	private documents = new Map<RelativePath, DocumentMetadata>();
+	private lastSeenUpdateId: VaultUpdateId | undefined;
+
+	public constructor(
+		initialState: Partial<StoredDatabase> | undefined,
+		private readonly saveData: (data: unknown) => Promise<void>
+	) {
+		initialState ??= {};
+		if (initialState.documents) {
+			for (const [relativePath, metadata] of Object.entries(
+				initialState.documents
+			)) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+				this.documents.set(relativePath, metadata as DocumentMetadata);
+			}
+		}
+		Logger.getInstance().debug(`Loaded ${this.documents.size} documents`);
+
+		this.lastSeenUpdateId = initialState.lastSeenUpdateId;
+		Logger.getInstance().debug(
+			`Loaded last seen update id: ${this.lastSeenUpdateId}`
+		);
+	}
+
+	public getDocuments(): Map<RelativePath, DocumentMetadata> {
+		return this.documents;
+	}
+
+	public getLastSeenUpdateId(): VaultUpdateId | undefined {
+		return this.lastSeenUpdateId;
+	}
+
+	public async setLastSeenUpdateId(
+		value: VaultUpdateId | undefined
+	): Promise<void> {
+		this.lastSeenUpdateId = value;
+		await this.save();
+	}
+
+	public async resetSyncState(): Promise<void> {
+		this.documents = new Map();
+		this.lastSeenUpdateId = 0;
+		await this.save();
+	}
+
+	public getDocumentByDocumentId(
+		documentId: DocumentId
+	): [RelativePath, DocumentMetadata] | undefined {
+		return [...this.documents.entries()].find(
+			([_, metadata]) => metadata.documentId === documentId
+		);
+	}
+
+	public async setDocument({
+		documentId,
+		relativePath,
+		parentVersionId,
+		hash
+	}: {
+		documentId: DocumentId;
+		relativePath: RelativePath;
+		parentVersionId: VaultUpdateId;
+		hash: string;
+	}): Promise<void> {
+		this.documents.set(relativePath, {
+			documentId,
+			parentVersionId,
+			hash
+		});
+		await this.save();
+	}
+
+	public async moveDocument({
+		documentId,
+		oldRelativePath,
+		relativePath,
+		parentVersionId,
+		hash
+	}: {
+		documentId: DocumentId;
+		oldRelativePath: RelativePath;
+		relativePath: RelativePath;
+		parentVersionId: VaultUpdateId;
+		hash: string;
+	}): Promise<void> {
+		this.documents.delete(oldRelativePath);
+		this.documents.set(relativePath, {
+			documentId,
+			parentVersionId,
+			hash
+		});
+		await this.save();
+	}
+
+	public async removeDocument(relativePath: RelativePath): Promise<void> {
+		this.documents.delete(relativePath);
+		await this.save();
+	}
+
+	public getDocument(
+		relativePath: RelativePath
+	): DocumentMetadata | undefined {
+		return this.documents.get(relativePath);
+	}
+
+	private async save(): Promise<void> {
+		await this.saveData({
+			documents: Object.fromEntries(this.documents.entries()),
+			lastSeenUpdateId: this.lastSeenUpdateId
+		});
+	}
+}

frontend/sync-client/src/persistence/settings.ts

@@ -0,0 +1,86 @@
+import { Logger, LogLevel } from "src/tracing/logger";
+
+export interface SyncSettings {
+	remoteUri: string;
+	token: string;
+	vaultName: string;
+	fetchChangesUpdateIntervalMs: number;
+	syncConcurrency: number;
+	isSyncEnabled: boolean;
+	displayNoopSyncEvents: boolean;
+	minimumLogLevel: LogLevel;
+	maxFileSizeMB: number;
+}
+
+const DEFAULT_SETTINGS: SyncSettings = {
+	remoteUri: "",
+	token: "",
+	vaultName: "default",
+	fetchChangesUpdateIntervalMs: 1000,
+	syncConcurrency: 1,
+	isSyncEnabled: false,
+	displayNoopSyncEvents: false,
+	minimumLogLevel: LogLevel.INFO,
+	maxFileSizeMB: 10
+};
+
+export class Settings {
+	private settings: SyncSettings;
+
+	private readonly onSettingsChangeHandlers: ((
+		newSettings: SyncSettings,
+		oldSettings: SyncSettings
+	) => void)[] = [];
+
+	public constructor(
+		initialState: Partial<SyncSettings> | undefined,
+		private readonly saveData: (data: unknown) => Promise<void>
+	) {
+		this.settings = {
+			...DEFAULT_SETTINGS,
+			...(initialState ?? {})
+		};
+
+		Logger.getInstance().debug(
+			`Loaded settings: ${JSON.stringify(this.settings, null, 2)}`
+		);
+	}
+
+	public getSettings(): SyncSettings {
+		return this.settings;
+	}
+
+	public async setSettings(value: SyncSettings): Promise<void> {
+		const oldSettings = this.settings;
+		this.settings = value;
+		this.onSettingsChangeHandlers.forEach((handler) => {
+			handler(value, oldSettings);
+		});
+		await this.save();
+	}
+
+	public addOnSettingsChangeHandlers(
+		handler: (settings: SyncSettings, oldSettings: SyncSettings) => void
+	): void {
+		this.onSettingsChangeHandlers.push(handler);
+	}
+
+	public async setSetting<T extends keyof SyncSettings>(
+		key: T,
+		value: SyncSettings[T]
+	): Promise<void> {
+		const newSettings = { ...this.settings, [key]: value };
+		Logger.getInstance().debug(
+			`Setting ${key} to ${value}, new settings: ${JSON.stringify(
+				newSettings,
+				null,
+				2
+			)}`
+		);
+		await this.setSettings(newSettings);
+	}
+
+	private async save(): Promise<void> {
+		await this.saveData(this.settings);
+	}
+}