@syncular/transport-http 0.0.1 → 0.0.2-126

package/src/index.ts

@@ -5,10 +5,8 @@
  */
 
 import type {
-  SyncPullRequest,
-  SyncPullResponse,
-  SyncPushRequest,
-  SyncPushResponse,
+  SyncCombinedRequest,
+  SyncCombinedResponse,
   SyncTransport,
   SyncTransportBlobs,
   SyncTransportOptions,
@@ -106,6 +104,30 @@ export interface ClientOptions {
   transportPath?: SyncTransportPath;
 }
 
+function resolveRequestUrl(baseUrl: string, path: string): string {
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const isAbsolute = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(baseUrl);
+  if (isAbsolute) {
+    return new URL(normalizedPath, baseUrl).toString();
+  }
+  if (typeof location === 'undefined') {
+    return `${baseUrl.replace(/\/$/, '')}${normalizedPath}`;
+  }
+  return new URL(
+    `${baseUrl.replace(/\/$/, '')}${normalizedPath}`,
+    location.origin
+  ).toString();
+}
+
+function bytesToReadableStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+}
+
 /**
  * Create a typed API client for the full Syncular API.
  *
@@ -119,7 +141,7 @@ export interface ClientOptions {
  * });
  *
  * // Sync endpoints
- * const { data } = await client.POST('/sync/pull', { body: { ... } });
+ * const { data } = await client.POST('/sync', { body: { clientId: 'c1', pull: { ... } } });
  *
  * // Console endpoints
  * const { data: stats } = await client.GET('/console/stats');
@@ -185,6 +207,8 @@ export function createHttpTransport(
     'GET' in clientOrOptions
       ? clientOrOptions
       : createApiClient(clientOrOptions);
+  const transportOptions =
+    'GET' in clientOrOptions ? undefined : clientOrOptions;
 
   // Create blob operations using the typed OpenAPI client
   const blobs: SyncTransportBlobs = {
@@ -244,13 +268,13 @@ export function createHttpTransport(
   };
 
   return {
-    async pull(
-      request: SyncPullRequest,
+    async sync(
+      request: SyncCombinedRequest,
       transportOptions?: SyncTransportOptions
-    ): Promise<SyncPullResponse> {
+    ): Promise<SyncCombinedResponse> {
       const { data, error, response } = await executeWithAuthRetry(
         (signal) =>
-          client.POST('/sync/pull', {
+          client.POST('/sync', {
             body: request,
             ...(signal ? { signal } : {}),
           }),
@@ -259,22 +283,23 @@ export function createHttpTransport(
 
       if (error || !data) {
         throw new SyncTransportError(
-          `Pull failed: ${getErrorMessage(error) || response.statusText}`,
+          `Sync failed: ${getErrorMessage(error) || response.statusText}`,
           response.status
         );
       }
 
-      return data as SyncPullResponse;
+      return data as SyncCombinedResponse;
     },
 
-    async push(
-      request: SyncPushRequest,
+    async fetchSnapshotChunk(
+      request: { chunkId: string },
       transportOptions?: SyncTransportOptions
-    ): Promise<SyncPushResponse> {
+    ): Promise<Uint8Array> {
       const { data, error, response } = await executeWithAuthRetry(
         (signal) =>
-          client.POST('/sync/push', {
-            body: request,
+          client.GET('/sync/snapshot-chunks/{chunkId}', {
+            params: { path: { chunkId: request.chunkId } },
+            parseAs: 'blob',
             ...(signal ? { signal } : {}),
           }),
         transportOptions
@@ -282,36 +307,85 @@ export function createHttpTransport(
 
       if (error || !data) {
         throw new SyncTransportError(
-          `Push failed: ${getErrorMessage(error) || response.statusText}`,
+          `Snapshot chunk download failed: ${getErrorMessage(error) || response.statusText}`,
           response.status
         );
       }
 
-      return data as SyncPushResponse;
+      return new Uint8Array(await (data as Blob).arrayBuffer());
     },
 
-    async fetchSnapshotChunk(
+    async fetchSnapshotChunkStream(
       request: { chunkId: string },
-      transportOptions?: SyncTransportOptions
-    ): Promise<Uint8Array> {
-      const { data, error, response } = await executeWithAuthRetry(
-        (signal) =>
-          client.GET('/sync/snapshot-chunks/{chunkId}', {
-            params: { path: { chunkId: request.chunkId } },
-            parseAs: 'blob',
-            ...(signal ? { signal } : {}),
-          }),
-        transportOptions
+      options?: SyncTransportOptions
+    ): Promise<ReadableStream<Uint8Array>> {
+      if (!transportOptions) {
+        const bytes = await this.fetchSnapshotChunk(request, options);
+        return bytesToReadableStream(bytes);
+      }
+
+      const fetchImpl = transportOptions.fetch ?? globalThis.fetch;
+      const requestUrl = resolveRequestUrl(
+        transportOptions.baseUrl,
+        `/sync/snapshot-chunks/${encodeURIComponent(request.chunkId)}`
       );
 
-      if (error || !data) {
+      const performRequest = async (
+        signal?: AbortSignal
+      ): Promise<Response> => {
+        const headers = new Headers();
+        const extraHeaders = await transportOptions.getHeaders?.();
+        if (extraHeaders) {
+          for (const [key, value] of Object.entries(extraHeaders)) {
+            headers.set(key, value);
+          }
+        }
+        if (!headers.has('x-syncular-transport-path')) {
+          headers.set(
+            'x-syncular-transport-path',
+            transportOptions.transportPath ?? 'direct'
+          );
+        }
+        return fetchImpl(requestUrl, {
+          method: 'GET',
+          headers,
+          ...(signal ? { signal } : {}),
+        });
+      };
+
+      let response = await performRequest(options?.signal);
+      if (
+        (response.status === 401 || response.status === 403) &&
+        options?.onAuthError
+      ) {
+        const shouldRetry = await options.onAuthError();
+        if (shouldRetry) {
+          response = await performRequest(options.signal);
+        }
+      }
+
+      if (!response.ok) {
+        let reason = response.statusText || 'Request failed';
+        try {
+          const maybeJson = (await response.json()) as
+            | { error?: unknown; message?: unknown }
+            | undefined;
+          reason = getErrorMessage(maybeJson) || reason;
+        } catch {
+          // ignore parse failures
+        }
         throw new SyncTransportError(
-          `Snapshot chunk download failed: ${getErrorMessage(error) || response.statusText}`,
+          `Snapshot chunk download failed: ${reason}`,
           response.status
         );
       }
 
-      return new Uint8Array(await (data as Blob).arrayBuffer());
+      if (!response.body) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        return bytesToReadableStream(bytes);
+      }
+
+      return response.body as ReadableStream<Uint8Array>;
     },
 
     // Include blob operations