@spooky-sync/client-solid 0.0.1-canary.16 → 0.0.1-canary.160

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

@@ -0,0 +1,50 @@
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import { useDb } from './context';
+import type { 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>;
+}
+
+/**
+ * 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,
+  };
+}

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;
-}