@voltkit-rtc/client 0.7.1 → 0.7.3

package/src/recording.ts

@@ -53,25 +53,26 @@ export class RecordingError extends Error {
 }
 const delay = (ms: number) =>
   new Promise<void>((resolve) => setTimeout(resolve, ms));
+/** One POST to the recording API. */
+function recordingFetch(base: string, path: string, body: unknown, token?: string): Promise<Response> {
+  return fetch(`${base.replace(/\/$/, "")}/recording/upload${path}`, {
+    method: "POST",
+    credentials: "omit",
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(path.endsWith("/complete") ? 180000 : 15000),
+  });
+}
 export async function recordingRequest<T>(
   base: string,
   path: string,
   body: unknown,
   token?: string,
 ): Promise<T> {
-  const response = await fetch(
-    `${base.replace(/\/$/, "")}/recording/upload${path}`,
-    {
-      method: "POST",
-      credentials: "omit",
-      headers: {
-        "Content-Type": "application/json",
-        ...(token ? { Authorization: `Bearer ${token}` } : {}),
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(path.endsWith("/complete") ? 180000 : 15000),
-    },
-  );
+  const response = await recordingFetch(base, path, body, token);
   const result = (await response.json()) as {
     success: boolean;
     data?: T;
@@ -304,16 +305,53 @@ export class RecordingUploader {
     }
     this.sealed = true;
   }
+  /**
+   * How long complete() waits before asking `/complete` again when the
+   * answer was lost or unclear: one wait per extra attempt. Exposed for tests.
+   * @internal
+   */
+  static completeRetryDelaysMs = [1000, 3000];
+
+  /**
+   * Finalise. An accepted `/complete` whose reply cannot be read rejects
+   * saying the recording completed. A lost or unclear answer (no reply, an
+   * unreadable one, a 5xx, 408/409/425/429) is asked again -- the service's
+   * completion is idempotent -- and if it is still unclear, rejects saying the
+   * recording may already be saved. Neither is aborted; only a readable
+   * refusal is final (V072-04).
+   */
   async complete(): Promise<RecordingFile> {
     await this.seal();
-    const file = await recordingRequest<RecordingFile>(
-      this.options.apiUrl,
-      `/sessions/${this.session.recording.id}/complete`,
-      {},
-      this.session.token,
-    );
-    this.emit("ready");
-    return file;
+    const path = `/sessions/${this.session.recording.id}/complete`;
+    for (let attempt = 0; ; attempt++) {
+      type Reply = { success?: unknown; data?: unknown; error?: { message?: string } };
+      let status = 0;
+      let body: Reply | null = null;
+      try {
+        const response = await recordingFetch(this.options.apiUrl, path, {}, this.session.token);
+        status = response.status;
+        const parsed: unknown = await response.json();
+        if (parsed && typeof parsed === "object") body = parsed as Reply;
+      } catch {
+        // Lost, cut short or unreadable: the service may have saved it.
+      }
+      if (body && status > 0 && status < 400 && body.success === true) {
+        const file = body.data as RecordingFile | null | undefined;
+        if (!file || typeof file !== "object" || typeof file.id !== "string") {
+          throw new RecordingError("The recording was completed but its reply could not be read", status);
+        }
+        this.emit("ready");
+        return file;
+      }
+      if (body && status > 0 && status < 500 && ![408, 409, 425, 429].includes(status)) {
+        throw new RecordingError(body.error?.message ?? "Recording request failed", status);
+      }
+      const delays = RecordingUploader.completeRetryDelaysMs;
+      if (attempt >= delays.length) {
+        throw new RecordingError("The service did not confirm the recording, which may already be saved; it was not aborted", status);
+      }
+      await delay(delays[attempt]);
+    }
   }
   async abort(): Promise<void> {
     this.canceled = true;