@spooky-sync/core 0.0.1-canary.280 → 0.0.1-canary.281

package/src/testing/fake-services.ts

@@ -24,7 +24,7 @@ export function fakeServiceBundle<S extends SchemaStructure>(over: Partial<Servi
     streamProcessor: { addReceiver: (r: unknown) => void receivers.push(r), checkpoint: async () => undefined, dispose: noop } as any,
     migrator: {} as any,
     crdt: { closeAll: noop, dispose: noop, open: async () => 'field', close: noop } as any,
-    auth: { subscribe: (cb: (u: string | null) => void) => (authListeners.push(cb), noop), subscribeImpersonation: () => noop, currentUser: null, isAuthenticated: false, impersonation: null, eventSystem: { subscribe: noop } } as any,
+    auth: { subscribe: (cb: (u: string | null) => void) => (authListeners.push(cb), noop), subscribeImpersonation: () => noop, onBeforeSignOut: () => noop, currentUser: null, isAuthenticated: false, token: null, impersonation: null, eventSystem: { subscribe: noop } } as any,
     tabs: null,
     tabsUnsupportedReason: 'test',
     tabId: 'tab-test',

package/src/types.ts

@@ -3,6 +3,7 @@ import type { RecordId, SchemaStructure, QueryPlan } from '@spooky-sync/query-bu
 import type { Level, LoggerOptions } from 'pino';
 import type { PushEventOptions } from './events/index';
 import type { LocalEngineChoice } from './services/database/cache-engine';
+import type { WebPushConfig } from './modules/web-push/index';
 
 export type { Level };
 
@@ -384,6 +385,16 @@ export interface Sp00kyConfig<S extends SchemaStructure> {
    * Defaults to 30000; `0` disables the timeout.
    */
   downTimeoutMs?: number;
+  /**
+   * Web Push on this page (`client.webPush`, `db.webPush`). Everything is
+   * optional and the defaults need no service worker configuration here:
+   * `autoSync` (repair this browser's subscription after sign-in),
+   * `unsubscribeOnSignOut` (drop this device's subscription on `signOut()`),
+   * `bridge` (post the session to the service worker for live rendering) are
+   * on; `serviceWorkerUrl` registers a worker when the app does not.
+   * See the `push-notifications` docs page.
+   */
+  webPush?: WebPushConfig;
 }
 
 /** Tunables for sync-health reporting. See {@link Sp00kyConfig.syncHealth}. */

package/src/utils/edges.ts

@@ -0,0 +1,39 @@
+import { RecordId } from 'surrealdb';
+import type { InlineRow } from '../types';
+import { encodeRecordId } from './index';
+
+/**
+ * Reading `_00_list_ref` edges as a LIVE notification delivers them. Pure, so
+ * both the full client and the wasm-free live feed (`@spooky-sync/core/live`)
+ * decode the same wire shape the same way.
+ */
+
+/** The hash a `_00_list_ref` edge belongs to: the id part of its `in` (`_00_query:<hash>`). */
+export function hashOfEdge(value: unknown): string | null {
+  const inId = (value as { in?: unknown } | null)?.in;
+  if (!inId) return null;
+  const str = inId instanceof RecordId ? String(inId.id) : String(inId).replace(/^_00_query:/, '');
+  return str.length > 0 ? str : null;
+}
+
+/**
+ * The row an edge notification carries, when the subscription joined it on.
+ *
+ * Without `FETCH out` the edge's `out` is a record id and there is nothing to
+ * land, so this returns null and the caller falls back to fetching the body.
+ * It also returns null for a row the session may not read (the join yields
+ * `out: null`) and for an edge whose target has been deleted.
+ */
+export function rowOfEdge(value: unknown): InlineRow | null {
+  const edge = value as { out?: unknown; version?: unknown } | null;
+  const out = edge?.out;
+  if (!out || typeof out !== 'object' || Array.isArray(out) || out instanceof RecordId) return null;
+  // Must be a real RecordId: the landing path keys off `row.id` being one, and
+  // would otherwise record the version for a body it never wrote.
+  const rid = (out as { id?: unknown }).id;
+  if (!(rid instanceof RecordId)) return null;
+  const id = encodeRecordId(rid);
+  const version = typeof edge?.version === 'number' ? edge.version : null;
+  if (version === null) return null;
+  return { id, version, record: out as Record<string, unknown> };
+}

package/src/utils/sha256.ts

@@ -0,0 +1,15 @@
+/**
+ * Lowercase hex SHA-256 of a UTF-8 string, through WebCrypto.
+ *
+ * Pure and dependency free so it can live in `@spooky-sync/core/pure` and run
+ * in a service worker, a dedicated worker or Node (`globalThis.crypto` is
+ * there on Node 19+). Query keys are `sha256Hex(JSON.stringify(..))`, see
+ * `query/hash.ts`.
+ */
+export async function sha256Hex(input: string): Promise<string> {
+  const bytes = new TextEncoder().encode(input);
+  const digest = await crypto.subtle.digest('SHA-256', bytes);
+  return Array.from(new Uint8Array(digest))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}

package/tsdown.config.ts

@@ -70,7 +70,8 @@ const workerUrlPlugin = {
   },
 };
 
-export default defineConfig({
+export default defineConfig([
+  {
   // `sqlite-worker` is emitted at `dist/sqlite-worker.js` (top level, NOT under
   // services/database) so the `new URL('./sqlite-worker.js', import.meta.url)`
   // in `SqliteCacheEngine` — which gets bundled into the flat `dist/index.js` —
@@ -91,4 +92,32 @@ export default defineConfig({
   clean: true,
   hash: false,
   plugins: [versionDefinePlugin, workerUrlPlugin],
-});
+  },
+  // The wasm-free entries a service worker, a dedicated worker or Node can
+  // import: `/pure` (protocol builders), `/live` (the live feed over the
+  // pure-JS `surrealdb` SDK) and `/sw` (push handlers). Built separately so
+  // they never share a chunk with `index` (whose graph holds the wasm engines)
+  // and so `dist/index.js` stays one flat file. They may share chunks among
+  // themselves; scripts/check-worker-entries.mjs walks those too and fails
+  // the build on any wasm/pino import or top-level window/document access.
+  {
+    entry: {
+      pure: 'src/pure.ts',
+      live: 'src/live/index.ts',
+      sw: 'src/sw/index.ts',
+    },
+    format: ['esm'],
+    dts: true,
+    clean: false,
+    hash: false,
+    // Own prefix so a chunk of this build never overwrites one of the first
+    // (both write `dist/`; `types.d.ts` collided).
+    // The entries' own declaration files arrive as chunks named `<entry>.d`
+    // and must keep their plain name.
+    outputOptions: {
+      chunkFileNames: (chunk: { name: string }) =>
+        ['pure.d', 'live.d', 'sw.d'].includes(chunk.name) ? '[name].js' : 'worker-[name].js',
+    },
+    plugins: [versionDefinePlugin],
+  },
+]);