@wells-nelson/data-storage 0.0.1 → 1.0.1

package/README.md

@@ -63,6 +63,21 @@ onMount(() => void store.init({ beforeReady: importDevSeed }));
 Without roles everyone is an owner. Table and RPC names default to `<noun>_members` and
 `get_<noun>_members`; override with e.g. `members: { membersRpc: 'get_list_collaborators' }`.
 
+## A schema other than `public`
+
+To keep an app's tables in their own Postgres schema (handy when several apps share one Supabase
+project), set `supabaseSchema` on the store and the same `schema` on the migration:
+
+```ts
+createSyncedStore({ ..., supabaseSchema: 'my_app' });
+generateMigration({ ..., schema: 'my_app' });
+```
+
+The migration creates the schema with the grants Supabase's API roles need. In the Supabase
+dashboard, add the schema under **Project Settings → Data API → Exposed schemas**; until then,
+the API can't see it. The store's client reads and writes that schema. It also fixes RxDB's
+realtime subscription, which otherwise always listens on `public`.
+
 ## SQL migration
 
 ```ts

package/dist/cloud.svelte.d.ts

@@ -1,11 +1,15 @@
 import type { User } from '@supabase/supabase-js';
 import type { AppState } from './app.svelte.js';
 import { type StorageFactory } from './database.js';
-import type { SupabaseApi } from './supabase.js';
+import { type SupabaseApi } from './supabase.js';
 import { type DocMap, type Role, type StoreSchema } from './types.js';
 /** Push errors caused by the server refusing the write (RLS, triggers), not by connectivity. */
 export declare function isRejection(err: unknown): boolean;
-export declare function errorMessage(err: unknown): string;
+/**
+ * A replication or API error as one line for the UI. With `schema`, a schema the Supabase API
+ * doesn't expose is reported as the setting to change.
+ */
+export declare function errorMessage(err: unknown, schema?: string): string;
 export interface CloudSyncOptions<D extends DocMap> {
     /** Prefix for database names and localStorage keys, e.g. 'demo'. */
     appKey: string;

package/dist/cloud.svelte.js

@@ -3,6 +3,7 @@ import { tick } from 'svelte';
 import { openDatabase } from './database.js';
 import { createDataSet, disposeDataSet } from './dataset.js';
 import { Persisted } from './persisted.svelte.js';
+import { replicationClient, schemaNotExposed } from './supabase.js';
 import { containerIdOf } from './types.js';
 const emptyState = () => ({ pending: {}, blocked: [], revoked: [], roles: {}, lastSync: null });
 const MEMBERSHIP_CHECK_INTERVAL = 30_000;
@@ -15,10 +16,16 @@ export function isRejection(err) {
     // 42501: RLS violation; P0001: raised by a trigger (e.g. last owner); 23xxx: constraint violations.
     return !!code && (code === '42501' || code === 'P0001' || code.startsWith('23'));
 }
-export function errorMessage(err) {
+/**
+ * A replication or API error as one line for the UI. With `schema`, a schema the Supabase API
+ * doesn't expose is reported as the setting to change.
+ */
+export function errorMessage(err, schema) {
     if (err && typeof err === 'object') {
         const e = err;
-        return e.parameters?.errors?.[0]?.message ?? e.message ?? String(err);
+        const inner = e.parameters?.errors?.[0];
+        const unexposed = schema ? (schemaNotExposed(inner, schema) ?? schemaNotExposed(e, schema)) : null;
+        return unexposed ?? inner?.message ?? e.message ?? String(err);
     }
     return String(err);
 }
@@ -164,7 +171,7 @@ export class CloudSync {
         this.#scheduleSettle();
     }
     #startReplication(db) {
-        const sb = this.#sb.getClient();
+        const sb = replicationClient(this.#sb.getClient(), this.#sb.schema);
         this.#schema.collections.forEach((name, index) => {
             const rep = replicateSupabase({
                 replicationIdentifier: `supabase-${name}`,
@@ -183,7 +190,7 @@ export class CloudSync {
             });
             this.#replications.push(rep);
             this.#subscriptions.push(rep.error$.subscribe((err) => {
-                this.error = errorMessage(err);
+                this.error = errorMessage(err, this.#sb.schema);
                 if (isRejection(err))
                     this.rejectedWrite = this.error;
             }), rep.active$.subscribe((isActive) => {
@@ -307,7 +314,7 @@ export class CloudSync {
             });
         }
         catch (err) {
-            this.error = errorMessage(err);
+            this.error = errorMessage(err, this.#sb.schema);
         }
     }
     async forceResync() {

package/dist/index.d.ts

@@ -8,6 +8,6 @@ export { Persisted } from './persisted.svelte.js';
 export { DevicePrefs, defaultPrefsKeys, type DevicePrefsKeys } from './prefs.svelte.js';
 export { field, flatSchema, type FieldSpec } from './schema.js';
 export { createSyncedStore, type SyncedStore, type SyncedStoreConfig } from './store.js';
-export { createSupabaseApi, friendlyError, type Member, type MembersConfig, type SupabaseApi } from './supabase.js';
+export { createSupabaseApi, friendlyError, replicationClient, schemaNotExposed, type Member, type MembersConfig, type SupabaseApi, type SupabaseOptions } from './supabase.js';
 export { Tombstones } from './tombstones.svelte.js';
 export { containerIdOf, type CollectionName, type DocBase, type DocMap, type Location, type Nouns, type Role, type StoreSchema } from './types.js';

package/dist/index.js

@@ -8,6 +8,6 @@ export { Persisted } from './persisted.svelte.js';
 export { DevicePrefs, defaultPrefsKeys } from './prefs.svelte.js';
 export { field, flatSchema } from './schema.js';
 export { createSyncedStore } from './store.js';
-export { createSupabaseApi, friendlyError } from './supabase.js';
+export { createSupabaseApi, friendlyError, replicationClient, schemaNotExposed } from './supabase.js';
 export { Tombstones } from './tombstones.svelte.js';
 export { containerIdOf } from './types.js';

package/dist/sql.d.ts

@@ -32,6 +32,12 @@ export interface MigrationConfig {
     roles?: boolean;
     membersTable?: string;
     membersRpc?: string;
+    /**
+     * Postgres schema for every table, type and function (default 'public'). Any other schema is
+     * created with the grants Supabase needs; also expose it in the project's Data API settings and
+     * pass the same name as `supabaseSchema` to the store.
+     */
+    schema?: string;
 }
 /**
  * Turn RxDB flat schemas into migration tables. `refs` fields (and the container field) become

package/dist/sql.js

@@ -7,6 +7,25 @@
  *
  * Pure string building: no database or Svelte dependency, so it runs from a plain Node script.
  */
+/** Move everything the migration creates from `public` into `schema` (`auth.*` is untouched). */
+function inSchema(sql, schema) {
+    const setup = `-- ---------------------------------------------------------------- schema
+
+create schema if not exists ${schema};
+
+-- The API roles need the same access Supabase grants on public; row level security on every
+-- table still decides what each user can read and write.
+grant usage on schema ${schema} to anon, authenticated, service_role;
+alter default privileges in schema ${schema} grant all on tables to anon, authenticated, service_role;
+alter default privileges in schema ${schema} grant all on functions to anon, authenticated, service_role;
+alter default privileges in schema ${schema} grant all on sequences to anon, authenticated, service_role;
+
+`;
+    return sql
+        .replaceAll('public.', `${schema}.`)
+        .replaceAll('set search_path = public', `set search_path = ${schema}`)
+        .replace('-- ---------------------------------------------------------------- helpers', `${setup}-- ---------------------------------------------------------------- helpers`);
+}
 const SQL_TYPES = { text: 'text', number: 'double precision', boolean: 'boolean' };
 const DEFAULTS = { text: "''", number: '0', boolean: 'false' };
 function columnSql(name, spec) {
@@ -33,7 +52,9 @@ export function tablesFromSchemas(collections, schemas, options) {
     });
 }
 export function generateMigration(config) {
-    const { container, containerField: cf, noun, roles = false } = config;
+    const { container, containerField: cf, noun, roles = false, schema = 'public' } = config;
+    if (!/^[a-z_][a-z0-9_]*$/.test(schema))
+        throw new Error(`Not a valid schema name: "${schema}".`);
     const members = config.membersTable ?? `${noun}_members`;
     const rpc = config.membersRpc ?? `get_${noun}_members`;
     const isMember = `is_${noun}_member`;
@@ -270,5 +291,6 @@ grant execute on function public.${rpc}(text) to authenticated;
 alter publication supabase_realtime
   add table ${all.map((n) => `public.${n}`).join(', ')};
 `);
-    return out.join('');
+    const sql = out.join('');
+    return schema === 'public' ? sql : inSchema(sql, schema);
 }

package/dist/store.d.ts

@@ -22,6 +22,11 @@ export interface SyncedStoreConfig<D extends DocMap, C extends CollectionName<D>
     storage: StorageFactory;
     /** viewer / editor / owner roles (needs the roles variant of the SQL migration). */
     roles?: boolean;
+    /**
+     * Postgres schema for the app's tables and functions (default 'public'). A custom schema must be
+     * exposed in the Supabase project's Data API settings; generate its SQL with the same `schema`.
+     */
+    supabaseSchema?: string;
     /** Override membership table / RPC names (defaults: `<noun>_members`, `get_<noun>_members`). */
     members?: Partial<Omit<MembersConfig, 'roles' | 'containerField'>>;
     /** Fields per collection holding ids of other rows in the container (rewritten when copying). */

package/dist/store.js

@@ -21,7 +21,7 @@ export function createSyncedStore(config) {
         ...config.members,
         containerField: config.containerField,
         roles
-    });
+    }, { schema: config.supabaseSchema });
     const app = new AppState();
     const tombstones = new Tombstones(config.appKey);
     const prefs = config.prefs ?? new DevicePrefs(defaultPrefsKeys(config.appKey, config.nouns));

package/dist/supabase.d.ts

@@ -23,8 +23,17 @@ export interface Member {
     /** Only when roles are on. */
     role?: Role | null;
 }
+export interface SupabaseOptions {
+    /**
+     * Postgres schema holding the app's tables and functions (default 'public'). A custom schema
+     * must be listed under the Supabase project's exposed schemas (Data API settings).
+     */
+    schema?: string;
+}
 export interface SupabaseApi {
     readonly configured: boolean;
+    /** The Postgres schema the client reads and writes. */
+    readonly schema: string;
     /** The shared client (PKCE, created on first use), or null in local-only mode. */
     getClient(): SupabaseClient | null;
     fetchMembers(containerId: string): Promise<Member[]>;
@@ -36,10 +45,25 @@ export interface SupabaseApi {
     /** Every container the user belongs to, with their role (null without roles). */
     fetchMyMemberships(email: string): Promise<Map<string, Role | null>>;
 }
+/**
+ * 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.
+ */
+export declare function schemaNotExposed(error: {
+    message?: string;
+    code?: string;
+} | undefined, schema: string): string | null;
 /** Turn Postgres errors from triggers / RLS into messages a person can act on. */
 export declare function friendlyError(error: {
     message: string;
     code?: string;
-}, noun: string): Error;
+}, noun: string, schema?: string): Error;
 /** Supabase client plus the members API, with table and RPC names from `members`. */
-export declare function createSupabaseApi(env: EnvConfig, members: MembersConfig): SupabaseApi;
+export declare function createSupabaseApi(env: EnvConfig, members: MembersConfig, options?: SupabaseOptions): SupabaseApi;
+/**
+ * The client RxDB's Supabase replication should use. Its pulls and pushes go through
+ * `client.from()`, which follows the client's schema, but its realtime subscription always
+ * asks for schema 'public'. For any other schema this wraps the three methods the replication
+ * calls and points that subscription at the right schema.
+ */
+export declare function replicationClient(client: SupabaseClient, schema: string): SupabaseClient;

package/dist/supabase.js

@@ -1,6 +1,20 @@
 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.
+ */
+export function schemaNotExposed(error, schema) {
+    if (!error)
+        return null;
+    if (error.code !== 'PGRST106' && !/invalid schema|schema must be one of/i.test(error.message ?? ''))
+        return null;
+    return `Expose the ${schema} schema in Supabase (Project Settings → Data API).`;
+}
 /** Turn Postgres errors from triggers / RLS into messages a person can act on. */
-export function friendlyError(error, noun) {
+export function friendlyError(error, noun, schema = 'public') {
+    const unexposed = schemaNotExposed(error, schema);
+    if (unexposed)
+        return new Error(unexposed);
     if (error.message.includes('last owner')) {
         return new Error(`A ${noun} must always have at least one owner. Make someone else an owner first.`);
     }
@@ -11,14 +25,16 @@ export function friendlyError(error, noun) {
     return new Error(error.message);
 }
 /** Supabase client plus the members API, with table and RPC names from `members`. */
-export function createSupabaseApi(env, members) {
+export function createSupabaseApi(env, members, options = {}) {
     let client = null;
+    const schema = options.schema ?? 'public';
     const { table, containerField, membersRpc, roles, noun } = members;
     const rpcParam = members.rpcParam ?? `p_${containerField}`;
     function getClient() {
         if (!env.cloudConfigured)
             return null;
         client ??= createClient(env.supabaseUrl, env.supabaseAnonKey, {
+            db: { schema },
             auth: { flowType: 'pkce', persistSession: true, autoRefreshToken: true, detectSessionInUrl: true }
         });
         return client;
@@ -31,10 +47,11 @@ export function createSupabaseApi(env, members) {
     }
     const fail = (error) => {
         if (error)
-            throw friendlyError(error, noun);
+            throw friendlyError(error, noun, schema);
     };
     return {
         configured: env.cloudConfigured,
+        schema,
         getClient,
         async fetchMembers(containerId) {
             const { data, error } = await requireClient().rpc(membersRpc, { [rpcParam]: containerId });
@@ -75,3 +92,24 @@ export function createSupabaseApi(env, members) {
         }
     };
 }
+/**
+ * The client RxDB's Supabase replication should use. Its pulls and pushes go through
+ * `client.from()`, which follows the client's schema, but its realtime subscription always
+ * asks for schema 'public'. For any other schema this wraps the three methods the replication
+ * calls and points that subscription at the right schema.
+ */
+export function replicationClient(client, schema) {
+    if (schema === 'public')
+        return client;
+    const adapter = {
+        from: (table) => client.from(table),
+        removeChannel: (channel) => client.removeChannel(channel),
+        channel: (name, opts) => {
+            const channel = client.channel(name, opts);
+            const on = channel.on.bind(channel);
+            channel.on = (type, filter, cb) => on(type, type === 'postgres_changes' ? { ...filter, schema } : filter, cb);
+            return channel;
+        }
+    };
+    return adapter;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wells-nelson/data-storage",
-  "version": "0.0.1",
+  "version": "1.0.1",
   "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": {