@syncular/core 0.1.2 → 0.2.0

package/src/http/transport-client.ts

@@ -1,314 +0,0 @@
-import type {
-  SyncAuthErrorContext,
-  SyncAuthLifecycle,
-  SyncCombinedRequest,
-  SyncCombinedResponse,
-} from '@syncular/core';
-import {
-  decodeBinarySyncPack,
-  isBinarySyncPackContentType,
-} 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/core/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) => {
-    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,
-      };
-    }
-
-    if (isBinarySyncPackContentType(response.headers.get('content-type'))) {
-      return {
-        response,
-        data: decodeBinarySyncPack(
-          new Uint8Array(await response.arrayBuffer())
-        ) 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
-  );
-}