@syncular/client 0.0.6-96 → 0.1.0

package/src/react-native/index.ts

@@ -0,0 +1,152 @@
+import {
+  type CreateSyncularBridgeClientOptions,
+  createSyncularBridgeClient,
+  type SyncularAuthLeaseRecord,
+  type SyncularBridge,
+  type SyncularBridgeMutationBatch,
+  type SyncularBridgeQueryRequest,
+  type SyncularBridgeQueryResult,
+  type SyncularBridgeStatus,
+  type SyncularClientEventMap,
+  type SyncularClientEventSink,
+  type SyncularClientEventType,
+  type SyncularClientLike,
+  type SyncularConflictResolution,
+  type SyncularConflictSummary,
+  type SyncularDiagnosticSnapshot,
+  type SyncularPresenceEntry,
+  type SyncularPresenceSink,
+  type SyncularSubscriptionSpec,
+  type SyncularSyncResult,
+} from '@syncular/client';
+import type { SyncAuthLeaseIssueRequest } from '@syncular/core';
+
+export type SyncularNativeEventSubscription = (() => void) | { remove(): void };
+
+export interface SyncularNativeModule {
+  executeSql<Row extends Record<string, unknown> = Record<string, unknown>>(
+    request: SyncularBridgeQueryRequest
+  ): Promise<SyncularBridgeQueryResult<Row>> | SyncularBridgeQueryResult<Row>;
+  applyMutationsCommit(
+    batch: SyncularBridgeMutationBatch
+  ): Promise<string> | string;
+  applyLeasedMutationsCommit?(
+    batch: SyncularBridgeMutationBatch
+  ): Promise<string> | string;
+  sync?(): Promise<SyncularSyncResult>;
+  resumeFromBackground?(): Promise<SyncularSyncResult>;
+  start?(): Promise<void>;
+  stop?(): Promise<void>;
+  setSubscriptions?(
+    subscriptions: readonly SyncularSubscriptionSpec[]
+  ): Promise<void>;
+  getStatus?(): SyncularBridgeStatus;
+  issueAuthLease?(
+    request: SyncAuthLeaseIssueRequest
+  ): Promise<SyncularAuthLeaseRecord>;
+  upsertAuthLease?(lease: SyncularAuthLeaseRecord): Promise<void>;
+  authLease?(leaseId: string): Promise<SyncularAuthLeaseRecord | null>;
+  activeAuthLeases?(
+    actorId?: string | null,
+    nowMs?: number
+  ): Promise<SyncularAuthLeaseRecord[]>;
+  diagnosticSnapshot?(): Promise<SyncularDiagnosticSnapshot>;
+  addListener?<T extends SyncularClientEventType>(
+    event: T,
+    listener: SyncularClientEventSink<T>
+  ): SyncularNativeEventSubscription;
+  getPresence?<TMetadata = Record<string, unknown>>(
+    scopeKey: string
+  ): SyncularPresenceEntry<TMetadata>[];
+  joinPresence?(scopeKey: string, metadata?: Record<string, unknown>): void;
+  leavePresence?(scopeKey: string): void;
+  updatePresenceMetadata?(
+    scopeKey: string,
+    metadata: Record<string, unknown>
+  ): void;
+  conflictSummaries?(): Promise<SyncularConflictSummary[]>;
+  retryConflictKeepLocal?(id: string): Promise<string>;
+  resolveConflict?(
+    id: string,
+    resolution: SyncularConflictResolution
+  ): Promise<void>;
+}
+
+export interface CreateSyncularNativeClientOptions
+  extends Omit<CreateSyncularBridgeClientOptions, 'bridge'> {
+  module: SyncularNativeModule;
+}
+
+export async function createSyncularNativeClient<DB>(
+  options: CreateSyncularNativeClientOptions
+): Promise<SyncularClientLike<DB>> {
+  return createSyncularBridgeClient<DB>({
+    ...options,
+    bridge: createSyncularNativeBridge(options.module),
+  });
+}
+
+export function createSyncularNativeBridge(
+  module: SyncularNativeModule
+): SyncularBridge {
+  return {
+    executeSql: <Row extends Record<string, unknown>>(
+      request: SyncularBridgeQueryRequest
+    ) => module.executeSql<Row>(request),
+    applyMutationsCommit: (batch) => module.applyMutationsCommit(batch),
+    applyLeasedMutationsCommit: module.applyLeasedMutationsCommit?.bind(module),
+    sync: module.sync?.bind(module),
+    resumeFromBackground: module.resumeFromBackground?.bind(module),
+    start: module.start?.bind(module),
+    stop: module.stop?.bind(module),
+    setSubscriptions: module.setSubscriptions?.bind(module),
+    getStatus: module.getStatus?.bind(module),
+    issueAuthLease: module.issueAuthLease?.bind(module),
+    upsertAuthLease: module.upsertAuthLease?.bind(module),
+    authLease: module.authLease?.bind(module),
+    activeAuthLeases: module.activeAuthLeases?.bind(module),
+    diagnosticSnapshot: module.diagnosticSnapshot?.bind(module),
+    on: (event, listener) => removeable(module.addListener?.(event, listener)),
+    presence: {
+      get: (scopeKey) => module.getPresence?.(scopeKey) ?? [],
+      join: (scopeKey, metadata) => module.joinPresence?.(scopeKey, metadata),
+      leave: (scopeKey) => module.leavePresence?.(scopeKey),
+      updateMetadata: (scopeKey, metadata) =>
+        module.updatePresenceMetadata?.(scopeKey, metadata),
+      onChange: <TMetadata = Record<string, unknown>>(
+        listener: SyncularPresenceSink<TMetadata>
+      ) =>
+        removeable(
+          module.addListener?.('presenceChanged', (event) =>
+            listener(
+              event as SyncularClientEventMap['presenceChanged'] as Parameters<
+                SyncularPresenceSink<TMetadata>
+              >[0]
+            )
+          )
+        ),
+    },
+    conflicts: {
+      list: () => module.conflictSummaries?.() ?? Promise.resolve([]),
+      retryKeepLocal: (id) =>
+        module.retryConflictKeepLocal?.(id) ??
+        Promise.reject(
+          new Error('Syncular native module cannot retry conflicts.')
+        ),
+      resolve: (id, resolution) =>
+        module.resolveConflict?.(id, resolution) ??
+        Promise.reject(
+          new Error('Syncular native module cannot resolve conflicts.')
+        ),
+    },
+  };
+}
+
+function removeable(subscription: SyncularNativeEventSubscription | undefined) {
+  if (!subscription) return noop;
+  return typeof subscription === 'function'
+    ? subscription
+    : () => subscription.remove();
+}
+
+function noop(): void {}

package/src/runtime-contract.ts

@@ -0,0 +1,48 @@
+import type {
+  SyncularRuntimeInfo,
+  SyncularRustRuntimeInfo,
+  SyncularStorage,
+} from './types';
+import {
+  SYNCULAR_CLIENT_PACKAGE_NAME,
+  SYNCULAR_CLIENT_PACKAGE_VERSION,
+} from './wasm-bindings/runtime-contract';
+import { SYNCULAR_WORKER_PROTOCOL_VERSION } from './worker-protocol';
+
+export {
+  SYNCULAR_CORE_RUNTIME_FEATURES,
+  SYNCULAR_FULL_RUNTIME_FEATURES,
+  SYNCULAR_WASM_ARTIFACT_CATALOG_FILE,
+  SYNCULAR_WASM_ARTIFACT_FILE,
+  SYNCULAR_WASM_BINARY_FILE,
+  SYNCULAR_WASM_GLUE_FILE,
+  SYNCULAR_WASM_OUT_NAME,
+} from './wasm-bindings/runtime-contract';
+export { SYNCULAR_WORKER_PROTOCOL_VERSION } from './worker-protocol';
+
+export const SYNCULAR_PACKAGE_NAME = SYNCULAR_CLIENT_PACKAGE_NAME;
+export const SYNCULAR_PACKAGE_VERSION = SYNCULAR_CLIENT_PACKAGE_VERSION;
+
+export function createSyncularRuntimeInfo(options: {
+  storage?: SyncularStorage;
+  workerUrl?: string | URL;
+  wasmGlueUrl: string | URL;
+  wasmUrl: string | URL | Request;
+  rust?: SyncularRustRuntimeInfo | null;
+}): SyncularRuntimeInfo {
+  return {
+    packageName: SYNCULAR_PACKAGE_NAME,
+    packageVersion: SYNCULAR_PACKAGE_VERSION,
+    workerProtocolVersion: SYNCULAR_WORKER_PROTOCOL_VERSION,
+    storage: options.storage,
+    workerUrl: options.workerUrl == null ? undefined : href(options.workerUrl),
+    wasmGlueUrl: href(options.wasmGlueUrl),
+    wasmUrl: href(options.wasmUrl),
+    rust: options.rust ?? undefined,
+  };
+}
+
+function href(value: string | URL | Request): string {
+  if (value instanceof Request) return value.url;
+  return value instanceof URL ? value.href : value;
+}