@spooky-sync/client-solid 0.0.1-canary.26 → 0.0.1-canary.261

package/src/lib/use-storage-status.ts

@@ -0,0 +1,44 @@
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import { useDb } from './context';
+import type { StorageHealth, StorageHealthStatus } from '@spooky-sync/core';
+
+export interface UseStorageStatus {
+  /** Full durability snapshot; updates reactively. */
+  health: Accessor<StorageHealth>;
+  /** `'unknown'` | `'persistent'` | `'memory'`. */
+  status: Accessor<StorageHealthStatus>;
+  /** `true` when the local store survives a reload. */
+  isPersistent: Accessor<boolean>;
+  /**
+   * `true` only when durable storage was requested and could NOT be opened, so
+   * the dataset is sitting in RAM and local writes die on reload. Drive a
+   * warning off this, not off `status`: a store configured as in-memory reports
+   * `'memory'` too, and that is a choice rather than a problem.
+   */
+  isMemoryFallback: Accessor<boolean>;
+}
+
+/**
+ * Observe how durable the LOCAL cache is, for a "no local storage" warning.
+ *
+ * Under `localEngine: 'sqlite'` with `store: 'indexeddb'` the durable store is
+ * the OPFS SAHPool VFS, and only ONE client per bucket can hold it open: a
+ * second tab of the same app cannot get it and runs in memory instead (the
+ * engine retries first, so a closing tab's lock is usually waited out). Must be
+ * used within a `<Sp00kyProvider>`.
+ */
+export function useStorageStatus(): UseStorageStatus {
+  const db = useDb();
+  // subscribeToStorageHealth fires synchronously with the current snapshot, so
+  // the signal is correct from the first read; the initial value avoids a flash.
+  const [health, setHealth] = createSignal<StorageHealth>(db.storageHealth);
+  const unsub = db.subscribeToStorageHealth(setHealth);
+  onCleanup(unsub);
+
+  return {
+    health,
+    status: () => health().status,
+    isPersistent: () => health().status === 'persistent',
+    isMemoryFallback: () => health().fallback,
+  };
+}

package/src/lib/use-sync-status.ts

@@ -0,0 +1,64 @@
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import { useDb } from './context';
+import type { ConnectionState, SyncHealth, SyncHealthStatus } from '@spooky-sync/core';
+
+export interface UseSyncStatus {
+  /** Full health snapshot; updates reactively on every transition. */
+  health: Accessor<SyncHealth>;
+  /** `'healthy'` | `'degraded'`. */
+  status: Accessor<SyncHealthStatus>;
+  isHealthy: Accessor<boolean>;
+  /** `true` once sync has failed for a sustained run — drive a banner off this. */
+  isDegraded: Accessor<boolean>;
+  /** `true` once at least one sync round has succeeded this session. */
+  everConnected: Accessor<boolean>;
+  /**
+   * `true` only for a real lost connection: degraded AFTER a first successful
+   * sync. Stays `false` during the initial "connecting" phase (degraded but
+   * never reached the server yet), so an indicator can show nothing until the
+   * app has actually connected once.
+   */
+  isOffline: Accessor<boolean>;
+  /**
+   * Transport state of the remote WebSocket. Flips the instant the socket
+   * drops, unlike `status`, which only degrades after a sustained run of failed
+   * sync rounds — so this is what to drive a "reconnecting…" affordance off.
+   */
+  connection: Accessor<ConnectionState>;
+  /**
+   * `true` while the connection is being re-established. Usually still
+   * `isHealthy()`: a short reconnect is invisible to sync, and writes made
+   * during it are queued locally and pushed once the socket is back.
+   */
+  isReconnecting: Accessor<boolean>;
+}
+
+/**
+ * Observe sync health for a "can't reach the server" banner / indicator.
+ *
+ * Backed by `db.subscribeToSyncHealth`. Individual sync failures (a transient
+ * remote 500 on query registration, a dropped socket) are absorbed by the
+ * retry and never flip this; `isDegraded()` only goes true once failures
+ * persist for the configured number of consecutive rounds (sp00ky core config
+ * `syncHealth.degradeAfterConsecutiveFailures`, default 3), and flips back on
+ * the next successful round. Must be used within a `<Sp00kyProvider>`.
+ */
+export function useSyncStatus(): UseSyncStatus {
+  const db = useDb();
+  // subscribeToSyncHealth fires synchronously with the current status, so the
+  // signal is correct from first read; the initial value just avoids a flash.
+  const [health, setHealth] = createSignal<SyncHealth>(db.syncHealth);
+  const unsub = db.subscribeToSyncHealth(setHealth);
+  onCleanup(unsub);
+
+  return {
+    health,
+    status: () => health().status,
+    isHealthy: () => health().status === 'healthy',
+    isDegraded: () => health().status === 'degraded',
+    everConnected: () => health().everConnected,
+    isOffline: () => health().status === 'degraded' && health().everConnected,
+    connection: () => health().connection,
+    isReconnecting: () => health().connection === 'reconnecting',
+  };
+}

package/src/types/index.ts

@@ -1,7 +1,6 @@
-import type { Surreal } from 'surrealdb';
 import type { SyncedDb } from '../index';
-import { GenericSchema } from '../lib/models';
-import type { SpookyConfig } from '@spooky-sync/core';
+import type { GenericSchema } from '../lib/models';
+import type { Sp00kyConfig } from '@spooky-sync/core';
 import type { SchemaStructure, TableNames, GetTable, TableModel } from '@spooky-sync/query-builder';
 
 /**
@@ -44,7 +43,7 @@ export type InferRelationshipsFromConst<S extends SchemaStructure, Schema extend
 // Prettify helper expands types for better intellisense
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
-export type SyncedDbConfig<S extends SchemaStructure> = Prettify<SpookyConfig<S>>;
+export type SyncedDbConfig<S extends SchemaStructure> = Prettify<Sp00kyConfig<S>>;
 
 // export interface LocalDbConfig {
 //   name: string;

package/src/lib/SpookyProvider.ts

@@ -1,55 +0,0 @@
-import { createSignal, onMount, createComponent, createMemo, JSX, mergeProps } from 'solid-js';
-import type { SchemaStructure } from '@spooky/query-builder';
-import type { SyncedDbConfig } from '../types';
-import { SyncedDb } from '../index';
-import { SpookyContext } from './context';
-
-export interface SpookyProviderProps<S extends SchemaStructure> {
-  config: SyncedDbConfig<S>;
-  fallback?: JSX.Element;
-  onError?: (error: Error) => void;
-  onReady?: (db: SyncedDb<S>) => void;
-  children: JSX.Element;
-}
-
-export function SpookyProvider<S extends SchemaStructure>(
-  props: SpookyProviderProps<S>
-): JSX.Element {
-  const merged = mergeProps(
-    {
-      fallback: undefined as JSX.Element | undefined,
-    },
-    props
-  );
-
-  const [db, setDb] = createSignal<SyncedDb<S> | undefined>(undefined);
-
-  onMount(async () => {
-    try {
-      const instance = new SyncedDb<S>(merged.config);
-      await instance.init();
-      setDb(() => instance);
-      merged.onReady?.(instance);
-    } catch (e) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      if (merged.onError) {
-        merged.onError(error);
-      } else {
-        console.error('SpookyProvider: Failed to initialize database', error);
-      }
-    }
-  });
-
-  const content = createMemo(() => {
-    const instance = db();
-    if (!instance) return merged.fallback;
-    return createComponent(SpookyContext.Provider, {
-      value: instance,
-      get children() {
-        return merged.children;
-      },
-    });
-  });
-
-  return content as unknown as JSX.Element;
-}