@syncular/transport-http 0.0.6-185 → 0.0.6-201

package/src/transport-client.ts

@@ -0,0 +1,307 @@
+import type {
+  SyncAuthErrorContext,
+  SyncAuthLifecycle,
+  SyncCombinedRequest,
+  SyncCombinedResponse,
+} from '@syncular/core';
+import type { SyncClient } from './api-client';
+import {
+  type ApiResult,
+  type ClientOptions,
+  encodeSnapshotScopes,
+  type ResolveAuthRetry,
+  resolveRequestUrl,
+  SNAPSHOT_SCOPES_HEADER,
+} from './shared';
+
+export type { ClientOptions };
+
+export const HTTP_TRANSPORT_SOURCE = Symbol.for(
+  '@syncular/transport-http/source'
+);
+
+export type HttpTransportSource = SyncClient | ClientOptions;
+
+function isApiClientLike(value: unknown): value is SyncClient {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as SyncClient).GET === 'function' &&
+    typeof (value as SyncClient).POST === 'function'
+  );
+}
+
+interface TransportApiClient {
+  sync(
+    request: SyncCombinedRequest,
+    signal?: AbortSignal
+  ): Promise<ApiResult<SyncCombinedResponse>>;
+  initiateUpload(
+    args: { hash: string; size: number; mimeType: string },
+    signal?: AbortSignal
+  ): Promise<
+    ApiResult<{
+      exists: boolean;
+      uploadUrl?: string;
+      uploadMethod?: 'PUT' | 'POST';
+      uploadHeaders?: Record<string, string>;
+    }>
+  >;
+  completeUpload(
+    hash: string,
+    signal?: AbortSignal
+  ): Promise<ApiResult<{ ok: boolean; error?: string }>>;
+  getDownloadUrl(
+    hash: string,
+    signal?: AbortSignal
+  ): Promise<ApiResult<{ url: string; expiresAt: string }>>;
+  getSnapshotChunk(
+    chunkId: string,
+    scopeValues: Record<string, string | string[]> | undefined,
+    signal?: AbortSignal
+  ): Promise<ApiResult<Blob>>;
+}
+
+function isJsonContentType(contentType: string | null): boolean {
+  return contentType?.includes('application/json') === true;
+}
+
+async function parseErrorBody(response: Response): Promise<unknown> {
+  if (!isJsonContentType(response.headers.get('content-type'))) {
+    return undefined;
+  }
+  try {
+    return (await response.json()) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+async function parseJsonBody<T>(response: Response): Promise<T | undefined> {
+  if (!isJsonContentType(response.headers.get('content-type'))) {
+    return undefined;
+  }
+  try {
+    return (await response.json()) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+function createAuthRetryResolver(
+  defaultAuthLifecycle: SyncAuthLifecycle | undefined
+): ResolveAuthRetry {
+  let refreshInFlight: Promise<boolean> | null = null;
+
+  const runRefreshSingleFlight = async (
+    lifecycle: SyncAuthLifecycle,
+    context: SyncAuthErrorContext
+  ): Promise<boolean> => {
+    if (!lifecycle.refreshToken) return false;
+
+    if (!refreshInFlight) {
+      refreshInFlight = Promise.resolve(lifecycle.refreshToken(context))
+        .then((result) => Boolean(result))
+        .finally(() => {
+          refreshInFlight = null;
+        });
+    }
+
+    return refreshInFlight;
+  };
+
+  return async (context, options) => {
+    if (options?.onAuthError) {
+      return Boolean(await options.onAuthError());
+    }
+
+    const lifecycle = options?.authLifecycle ?? defaultAuthLifecycle;
+    if (!lifecycle) return false;
+
+    await lifecycle.onAuthExpired?.(context);
+
+    const refreshResult = await runRefreshSingleFlight(lifecycle, context);
+    if (lifecycle.retryWithFreshToken) {
+      return Boolean(
+        await lifecycle.retryWithFreshToken({ ...context, refreshResult })
+      );
+    }
+    return refreshResult;
+  };
+}
+
+function createRequestHeaders(
+  baseOptions: ClientOptions,
+  extraHeaders?: Record<string, string>
+): Promise<Headers> {
+  return Promise.resolve(baseOptions.getHeaders?.()).then((dynamicHeaders) => {
+    const headers = new Headers(extraHeaders);
+    if (dynamicHeaders) {
+      for (const [key, value] of Object.entries(dynamicHeaders)) {
+        headers.set(key, value);
+      }
+    }
+    if (!headers.has('x-syncular-transport-path')) {
+      headers.set(
+        'x-syncular-transport-path',
+        baseOptions.transportPath ?? 'direct'
+      );
+    }
+    return headers;
+  });
+}
+
+function createFetchApiClient(baseOptions: ClientOptions): TransportApiClient {
+  const fetchImpl = baseOptions.fetch ?? globalThis.fetch;
+
+  const request = async <T>(args: {
+    method: 'GET' | 'POST';
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    parseAs?: 'json' | 'blob';
+  }): Promise<ApiResult<T>> => {
+    const headers = await createRequestHeaders(baseOptions, args.headers);
+    let body: BodyInit | undefined;
+    if (args.body !== undefined) {
+      headers.set('content-type', 'application/json');
+      body = JSON.stringify(args.body);
+    }
+
+    const response = await fetchImpl(
+      resolveRequestUrl(baseOptions.baseUrl, args.path),
+      {
+        method: args.method,
+        headers,
+        body,
+        ...(args.signal ? { signal: args.signal } : {}),
+      }
+    );
+
+    if (!response.ok) {
+      return {
+        response,
+        error: await parseErrorBody(response),
+      };
+    }
+
+    if (args.parseAs === 'blob') {
+      return {
+        response,
+        data: (await response.blob()) as T,
+      };
+    }
+
+    return {
+      response,
+      data: await parseJsonBody<T>(response),
+    };
+  };
+
+  return {
+    sync: (requestBody, signal) =>
+      request({
+        method: 'POST',
+        path: '/sync',
+        body: requestBody,
+        signal,
+      }),
+    initiateUpload: (args, signal) =>
+      request({
+        method: 'POST',
+        path: '/sync/blobs/upload',
+        body: args,
+        signal,
+      }),
+    completeUpload: (hash, signal) =>
+      request({
+        method: 'POST',
+        path: `/sync/blobs/${encodeURIComponent(hash)}/complete`,
+        signal,
+      }),
+    getDownloadUrl: (hash, signal) =>
+      request({
+        method: 'GET',
+        path: `/sync/blobs/${encodeURIComponent(hash)}/url`,
+        signal,
+      }),
+    getSnapshotChunk: (chunkId, scopeValues, signal) =>
+      request({
+        method: 'GET',
+        path: `/sync/snapshot-chunks/${encodeURIComponent(chunkId)}`,
+        headers: (() => {
+          const encodedScopes = encodeSnapshotScopes(scopeValues);
+          return encodedScopes
+            ? {
+                [SNAPSHOT_SCOPES_HEADER]: encodedScopes,
+              }
+            : undefined;
+        })(),
+        signal,
+        parseAs: 'blob',
+      }),
+  };
+}
+
+function createTypedTransportClient(client: SyncClient): TransportApiClient {
+  return {
+    sync: (request, signal) =>
+      client.POST('/sync', {
+        body: request,
+        ...(signal ? { signal } : {}),
+      }) as Promise<ApiResult<SyncCombinedResponse>>,
+    initiateUpload: (args, signal) =>
+      client.POST('/sync/blobs/upload', {
+        body: args,
+        ...(signal ? { signal } : {}),
+      }) as Promise<
+        ApiResult<{
+          exists: boolean;
+          uploadUrl?: string;
+          uploadMethod?: 'PUT' | 'POST';
+          uploadHeaders?: Record<string, string>;
+        }>
+      >,
+    completeUpload: (hash, signal) =>
+      client.POST('/sync/blobs/{hash}/complete', {
+        params: { path: { hash } },
+        ...(signal ? { signal } : {}),
+      }) as Promise<ApiResult<{ ok: boolean; error?: string }>>,
+    getDownloadUrl: (hash, signal) =>
+      client.GET('/sync/blobs/{hash}/url', {
+        params: { path: { hash } },
+        ...(signal ? { signal } : {}),
+      }) as Promise<ApiResult<{ url: string; expiresAt: string }>>,
+    getSnapshotChunk: (chunkId, scopeValues, signal) =>
+      client.GET('/sync/snapshot-chunks/{chunkId}', {
+        params: { path: { chunkId } },
+        parseAs: 'blob',
+        headers: (() => {
+          const encodedScopes = encodeSnapshotScopes(scopeValues);
+          return encodedScopes
+            ? {
+                [SNAPSHOT_SCOPES_HEADER]: encodedScopes,
+              }
+            : undefined;
+        })(),
+        ...(signal ? { signal } : {}),
+      }) as Promise<ApiResult<Blob>>,
+  };
+}
+
+export function createTransportApiClient(
+  source: HttpTransportSource
+): TransportApiClient {
+  return isApiClientLike(source)
+    ? createTypedTransportClient(source)
+    : createFetchApiClient(source);
+}
+
+export function createTransportAuthRetryResolver(
+  source: HttpTransportSource
+): ResolveAuthRetry {
+  return createAuthRetryResolver(
+    isApiClientLike(source) ? undefined : source.authLifecycle
+  );
+}