@wells-nelson/data-storage 1.0.1 → 1.0.3

package/dist/supabase.js

@@ -1,4 +1,3 @@
-import { createClient } from '@supabase/supabase-js';
 /**
  * PostgREST refuses a schema that isn't exposed in the project's Data API settings (PGRST106,
  * "Invalid schema: …"). Returns the fix to show instead, or null for other errors.
@@ -24,23 +23,83 @@ export function friendlyError(error, noun, schema = 'public') {
         return new Error(`That email already has access to this ${noun}.`);
     return new Error(error.message);
 }
+/** supabase-js's own session key for a project URL. */
+export function defaultStorageKey(supabaseUrl) {
+    try {
+        return `sb-${new URL(supabaseUrl).hostname.split('.')[0]}-auth-token`;
+    }
+    catch {
+        return 'sb-auth-token';
+    }
+}
+/**
+ * Move a session stored under supabase-js's default key to `storageKey` (once, when the new key
+ * is empty). The old key is removed: two apps holding the same refresh token would revoke each
+ * other's session, so only the first app to start keeps it and the other signs in again.
+ */
+export function adoptSession(legacyKey, storageKey) {
+    if (legacyKey === storageKey)
+        return;
+    try {
+        if (localStorage.getItem(storageKey) !== null)
+            return;
+        const value = localStorage.getItem(legacyKey);
+        if (value === null)
+            return;
+        localStorage.setItem(storageKey, value);
+        localStorage.removeItem(legacyKey);
+        const verifier = localStorage.getItem(`${legacyKey}-code-verifier`);
+        if (verifier !== null) {
+            localStorage.setItem(`${storageKey}-code-verifier`, verifier);
+            localStorage.removeItem(`${legacyKey}-code-verifier`);
+        }
+    }
+    catch {
+        /* storage unavailable: nothing to move */
+    }
+}
 /** Supabase client plus the members API, with table and RPC names from `members`. */
 export function createSupabaseApi(env, members, options = {}) {
     let client = null;
+    let loading = null;
     const schema = options.schema ?? 'public';
+    const legacyKey = defaultStorageKey(env.supabaseUrl);
+    const storageKey = options.storageKey ?? legacyKey;
     const { table, containerField, membersRpc, roles, noun } = members;
     const rpcParam = members.rpcParam ?? `p_${containerField}`;
-    function getClient() {
+    function loadClient() {
         if (!env.cloudConfigured)
-            return null;
-        client ??= createClient(env.supabaseUrl, env.supabaseAnonKey, {
-            db: { schema },
-            auth: { flowType: 'pkce', persistSession: true, autoRefreshToken: true, detectSessionInUrl: true }
-        });
-        return client;
+            return Promise.resolve(null);
+        loading ??= (async () => {
+            const { createClient } = await import('@supabase/supabase-js');
+            adoptSession(legacyKey, storageKey);
+            client = createClient(env.supabaseUrl, env.supabaseAnonKey, {
+                db: { schema },
+                auth: { flowType: 'pkce', persistSession: true, autoRefreshToken: true, detectSessionInUrl: true, storageKey }
+            });
+            return client;
+        })();
+        // A failed download (offline on first use) can be retried later.
+        loading.catch(() => (loading = null));
+        return loading;
+    }
+    function mayHaveSession() {
+        if (!env.cloudConfigured)
+            return false;
+        try {
+            if (localStorage.getItem(storageKey) !== null || localStorage.getItem(legacyKey) !== null)
+                return true;
+        }
+        catch {
+            /* no storage: only a redirect can carry a session */
+        }
+        if (typeof location === 'undefined')
+            return false;
+        const params = new URLSearchParams(location.search);
+        return params.has('code') || params.has('error_description') || /access_token|error_description/.test(location.hash);
     }
-    function requireClient() {
-        const sb = getClient();
+    async function requireClient() {
+        const sb = await loadClient();
         if (!sb)
             throw new Error('Cloud sync is not configured.');
         return sb;
@@ -52,9 +111,12 @@ export function createSupabaseApi(env, members, options = {}) {
     return {
         configured: env.cloudConfigured,
         schema,
-        getClient,
+        storageKey,
+        loadClient,
+        getClient: () => client,
+        mayHaveSession,
         async fetchMembers(containerId) {
-            const { data, error } = await requireClient().rpc(membersRpc, { [rpcParam]: containerId });
+            const { data, error } = await (await requireClient()).rpc(membersRpc, { [rpcParam]: containerId });
             fail(error);
             return (data ?? []);
         },
@@ -62,21 +124,21 @@ export function createSupabaseApi(env, members, options = {}) {
             const row = { [containerField]: containerId, email: email.trim().toLowerCase() };
             if (roles)
                 row.role = role ?? 'viewer';
-            const { error } = await requireClient().from(table).insert(row);
+            const { error } = await (await requireClient()).from(table).insert(row);
             fail(error);
         },
         async setMemberRole(memberId, role) {
             if (!roles)
                 throw new Error('Roles are not enabled.');
-            const { error } = await requireClient().from(table).update({ role }).eq('id', memberId);
+            const { error } = await (await requireClient()).from(table).update({ role }).eq('id', memberId);
             fail(error);
         },
         async removeMember(memberId) {
-            const { error } = await requireClient().from(table).delete().eq('id', memberId);
+            const { error } = await (await requireClient()).from(table).delete().eq('id', memberId);
             fail(error);
         },
         async leave(containerId, email) {
-            const { error } = await requireClient()
+            const { error } = await (await requireClient())
                 .from(table)
                 .delete()
                 .eq(containerField, containerId)
@@ -85,7 +147,7 @@ export function createSupabaseApi(env, members, options = {}) {
         },
         async fetchMyMemberships(email) {
             const columns = roles ? `${containerField}, role` : containerField;
-            const { data, error } = await requireClient().from(table).select(columns).eq('email', email.toLowerCase());
+            const { data, error } = await (await requireClient()).from(table).select(columns).eq('email', email.toLowerCase());
             fail(error);
             const rows = (data ?? []);
             return new Map(rows.map((r) => [r[containerField], roles ? r.role : null]));

package/dist/types.d.ts

@@ -8,11 +8,15 @@ export interface DocBase {
     id: string;
     updated_at: number;
 }
-/** Collection name → document type, e.g. `{ projects: ProjectDoc; tasks: TaskDoc }`. */
-export type DocMap = {
-    [name: string]: DocBase;
+/**
+ * Collection name → document type, e.g. `{ projects: ProjectDoc; tasks: TaskDoc }`, as a `type`
+ * alias or an `interface`. Generics constrain with `D extends DocMap<D>` (every key of `D` is a
+ * document), which an interface satisfies; a plain `DocMap` is any such map.
+ */
+export type DocMap<D = Record<string, DocBase>> = {
+    [K in keyof D]: DocBase;
 };
-export type CollectionName<D extends DocMap> = keyof D & string;
+export type CollectionName<D extends DocMap<D>> = keyof D & string;
 /** Where a container lives: only on this device, or replicated to Supabase. */
 export type Location = 'local' | 'cloud';
 export type Role = 'viewer' | 'editor' | 'owner';
@@ -25,7 +29,7 @@ export interface Nouns {
  * The shape of an app's data. A **container** (a project, a list…) owns every other row through
  * `containerField` and is the unit that gets shared, synced and moved between data sets.
  */
-export interface StoreSchema<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> {
+export interface StoreSchema<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>> {
     /** Every collection, parents before children (the container first). */
     collections: readonly CollectionName<D>[];
     schemas: {
@@ -39,4 +43,4 @@ export interface StoreSchema<D extends DocMap, C extends CollectionName<D> = Col
     indexContainerField?: boolean;
 }
 /** The container a document belongs to (containers are their own container). */
-export declare function containerIdOf<D extends DocMap>(schema: Pick<StoreSchema<D>, 'container' | 'containerField'>, collection: CollectionName<D>, doc: object): string;
+export declare function containerIdOf<D extends DocMap<D>>(schema: Pick<StoreSchema<D>, 'container' | 'containerField'>, collection: CollectionName<D>, doc: object): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wells-nelson/data-storage",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Offline-first storage for Wells Nelson apps: RxDB + TanStack DB data sets, Supabase sync of shared containers, tombstones, device prefs and a SQL migration generator.",
   "license": "MIT",
   "repository": {