works

frontend/sync-client/src/services/connected-state.ts

@@ -0,0 +1,52 @@
+import { Syncer } from "../sync-operations/syncer";
+import { Settings } from "../persistence/settings";
+import { Logger } from "../tracing/logger";
+import { createPromise } from "../utils/create-promise";
+import { retriedFetchFactory } from "../utils/retried-fetch";
+
+export class ConnectedState {
+	private resolveIsSyncEnabled: (() => void) | undefined;
+	private syncIsEnabled: Promise<void> | undefined;
+
+	public constructor(
+		settings: Settings,
+		private readonly logger: Logger
+	) {
+		settings.addOnSettingsChangeHandlers((newSettings, oldSettings) => {
+			if (!oldSettings.isSyncEnabled && newSettings.isSyncEnabled) {
+				this.handleComingOnline();
+			} else if (
+				oldSettings.isSyncEnabled &&
+				!newSettings.isSyncEnabled
+			) {
+				this.handleGoingOffline();
+			}
+		});
+	}
+
+	private handleComingOnline() {
+		this.logger.debug("Sync is enabled");
+		this.resolveIsSyncEnabled?.();
+	}
+
+	private handleGoingOffline() {
+		this.logger.debug("Sync is disabled");
+		[this.syncIsEnabled, this.resolveIsSyncEnabled] = createPromise();
+	}
+
+	public getFetchImplementation(
+		fetch: typeof globalThis.fetch,
+		{ doRetries = true }: { doRetries: boolean } = { doRetries: true }
+	): typeof globalThis.fetch {
+		const retriedFetch = doRetries
+			? retriedFetchFactory(this.logger, fetch)
+			: fetch;
+
+		return async (input: RequestInfo | URL): Promise<Response> => {
+			if (this.syncIsEnabled !== undefined) {
+				await this.syncIsEnabled;
+			}
+			return retriedFetch(input);
+		};
+	}
+}

frontend/sync-client/src/services/sync-service.ts

@@ -6,20 +6,22 @@ import type {
 	RelativePath,
 	VaultUpdateId
 } from "../persistence/database";
-import type { Logger } from "src/tracing/logger";
-import { retriedFetchFactory } from "src/utils/retried-fetch";
-import type { Settings } from "src/persistence/settings";
+import type { Logger } from "../tracing/logger";
+import type { Settings } from "../persistence/settings";
+import { ConnectedState } from "./connected-state";
 
 export interface CheckConnectionResult {
 	isSuccessful: boolean;
 	message: string;
 }
+
 export class SyncService {
 	private client!: Client<paths>;
 	private clientWithoutRetries!: Client<paths>;
 	private _fetchImplementation: typeof globalThis.fetch = globalThis.fetch;
 
 	public constructor(
+		private readonly connectedState: ConnectedState,
 		private readonly settings: Settings,
 		private readonly logger: Logger
 	) {
@@ -52,17 +54,19 @@ export class SyncService {
 	}
 
 	public async create({
+		documentId,
 		relativePath,
-		contentBytes,
-		createdDate
+		contentBytes
 	}: {
+		documentId?: DocumentId;
 		relativePath: RelativePath;
 		contentBytes: Uint8Array;
-		createdDate: Date;
 	}): Promise<components["schemas"]["DocumentVersionWithoutContent"]> {
 		const formData = new FormData();
+		if (documentId !== undefined) {
+			formData.append("document_id", documentId);
+		}
 		formData.append("relative_path", relativePath);
-		formData.append("created_date", createdDate.toISOString());
 		formData.append("content", new Blob([contentBytes]));
 
 		const response = await this.client.POST(
@@ -100,21 +104,18 @@ export class SyncService {
 		parentVersionId,
 		documentId,
 		relativePath,
-		contentBytes,
-		createdDate
+		contentBytes
 	}: {
 		parentVersionId: VaultUpdateId;
 		documentId: DocumentId;
 		relativePath: RelativePath;
 		contentBytes: Uint8Array;
-		createdDate: Date;
 	}): Promise<components["schemas"]["DocumentUpdateResponse"]> {
 		this.logger.debug(
 			`Updating document ${documentId} with parent version ${parentVersionId} & ${new TextDecoder().decode(contentBytes)} & ${relativePath}`
 		);
 		const formData = new FormData();
 		formData.append("parent_version_id", parentVersionId.toString());
-		formData.append("created_date", createdDate.toISOString());
 		formData.append("relative_path", relativePath);
 		formData.append("content", new Blob([contentBytes]));
 
@@ -152,12 +153,10 @@ export class SyncService {
 
 	public async delete({
 		documentId,
-		relativePath,
-		createdDate
+		relativePath
 	}: {
 		documentId: DocumentId;
 		relativePath: RelativePath;
-		createdDate: Date;
 	}): Promise<components["schemas"]["DocumentVersionWithoutContent"]> {
 		const response = await this.client.DELETE(
 			"/vaults/{vault_id}/documents/{document_id}",
@@ -172,7 +171,6 @@ export class SyncService {
 					}
 				},
 				body: {
-					createdDate: createdDate.toISOString(),
 					relativePath
 				}
 			}
@@ -298,11 +296,17 @@ export class SyncService {
 	private createClient(remoteUri: string): void {
 		this.client = createClient<paths>({
 			baseUrl: remoteUri,
-			fetch: retriedFetchFactory(this.logger, this._fetchImplementation)
+			fetch: this.connectedState.getFetchImplementation(
+				this._fetchImplementation
+			)
 		});
 
 		this.clientWithoutRetries = createClient<paths>({
-			baseUrl: remoteUri
+			baseUrl: remoteUri,
+			fetch: this.connectedState.getFetchImplementation(
+				this._fetchImplementation,
+				{ doRetries: false }
+			)
 		});
 	}
 }