@runappsai/sdk 0.5.1 → 0.6.2

package/src/sync/remote.ts

@@ -0,0 +1,59 @@
+// sync/remote.ts — the sync engine's storage, over the files API.
+//
+// Shards are plain JSON files in the user's file space for the app, so
+// they share its quota, billing and deletion with everything else the
+// app stores for that user. Conditional reads (304) and writes (412 /
+// 409) come from the files API, which checks them against the store.
+
+import type { FilesService } from "../files.js";
+import type { APIError } from "../errors.js";
+import type { SyncRemote } from "./engine.js";
+
+export class FilesRemote implements SyncRemote {
+  constructor(private readonly files: FilesService) {}
+
+  async list(prefix: string): Promise<{ path: string; etag: string }[]> {
+    const out: { path: string; etag: string }[] = [];
+    let cursor: string | undefined;
+    do {
+      const page = await this.files.list({ prefix, limit: 1000, ...(cursor ? { cursor } : {}) });
+      for (const f of page.files) if (f.etag) out.push({ path: f.path, etag: f.etag });
+      cursor = page.next_cursor;
+    } while (cursor);
+    return out;
+  }
+
+  async getJSON(path: string, ifNoneMatch?: string) {
+    const r = await this.files.readJSON(path, ifNoneMatch ? { ifNoneMatch } : undefined);
+    if (r.notModified) return { status: "unchanged" as const };
+    if (r.value === undefined) return { status: "missing" as const };
+    return { status: "ok" as const, value: r.value, etag: r.etag ?? "" };
+  }
+
+  async putJSON(path: string, value: unknown, cond: { ifMatch?: string; ifNoneMatch?: boolean }) {
+    try {
+      const obj = await this.files.put(path, JSON.stringify(value), {
+        contentType: "application/json",
+        ...(cond.ifMatch ? { ifMatch: cond.ifMatch } : {}),
+        ...(cond.ifNoneMatch ? { ifNoneMatch: true } : {}),
+      });
+      return { status: "ok" as const, etag: obj.etag ?? "", serverTime: obj.last_modified ? Date.parse(obj.last_modified) : undefined };
+    } catch (e) {
+      const code = (e as APIError).statusCode;
+      if (code === 412 || code === 409) return { status: "conflict" as const };
+      throw e;
+    }
+  }
+
+  async putBlob(path: string, blob: Blob): Promise<void> {
+    try {
+      await this.files.put(path, blob, { contentType: blob.type || "application/octet-stream", ifNoneMatch: true });
+    } catch (e) {
+      if ((e as APIError).statusCode !== 409) throw e; // already stored: same bytes, same name
+    }
+  }
+
+  getBlob(path: string): Promise<Blob> {
+    return this.files.get(path);
+  }
+}

package/src/transport.ts

@@ -167,20 +167,25 @@ export class Transport {
    *  and the ETag of those bytes, when the server sends one. */
   async getRaw(
     path: string,
-    init?: { signal?: AbortSignal },
-  ): Promise<{ data: Uint8Array; contentType: string; etag?: string }> {
-    const resp = await this.fetchWithAuthRetry(path, async () => ({
-      method: "GET",
-      headers: await this.authHeaders(),
-      signal: init?.signal,
-    }));
+    init?: { signal?: AbortSignal; ifNoneMatch?: string },
+  ): Promise<{ data: Uint8Array; contentType: string; etag?: string; notModified?: boolean; serverTime?: number }> {
+    const resp = await this.fetchWithAuthRetry(path, async () => {
+      const headers: Record<string, string> = await this.authHeaders();
+      if (init?.ifNoneMatch) headers["If-None-Match"] = `"${init.ifNoneMatch.replace(/"/g, "")}"`;
+      return { method: "GET", headers, signal: init?.signal };
+    });
+    const serverTime = parseServerDate(resp.headers.get("date"));
+    if (resp.status === 304) {
+      const etag = (resp.headers.get("etag") ?? "").replace(/"/g, "") || init?.ifNoneMatch;
+      return { data: new Uint8Array(0), contentType: "", etag, notModified: true, serverTime };
+    }
     if (!resp.ok) {
       throw await this.parseError(resp);
     }
     const buf = new Uint8Array(await resp.arrayBuffer());
     const contentType = resp.headers.get("content-type") ?? "";
     const etag = (resp.headers.get("etag") ?? "").replace(/"/g, "") || undefined;
-    return { data: buf, contentType, etag };
+    return { data: buf, contentType, etag, serverTime };
   }
 
   /** POST a multipart/form-data body. Used by audio.transcribe and image.edit. */
@@ -308,3 +313,10 @@ export class Transport {
     return new APIError(resp.status, type, message);
   }
 }
+
+/** The server's clock from a Date header, as ms since epoch. */
+export function parseServerDate(h: string | null): number | undefined {
+  if (!h) return undefined;
+  const t = Date.parse(h);
+  return Number.isNaN(t) ? undefined : t;
+}