@wells-nelson/data-storage 1.0.2 → 1.1.0

package/README.md

@@ -14,6 +14,7 @@ Peer dependencies: `svelte`, `rxdb`, `rxjs`, `@tanstack/db`, `@tanstack/rxdb-db-
 import { createSyncedStore, envConfig, field, flatSchema } from '@wells-nelson/data-storage';
 import { getRxStorageDexie } from 'rxdb/plugins/storage-dexie';
 
+// Docs maps collection names to document types, as a `type` or an `interface`.
 // Pass the container collection as the second type argument so its rows are typed precisely.
 export const store = createSyncedStore<Docs, 'projects'>({
 	appKey: 'demo', // demo_local, demo_cloud_<user>, demo:hidden, demo:sync:<user>, demo:defaultProject…
@@ -51,7 +52,9 @@ onMount(() => void store.init({ beforeReady: importDevSeed }));
   show it until dismissed) and `persisted` (whether the browser keeps the data for good).
 - `cloud`: `CloudSync`: session (Google, email link), replication, `pendingIds`, `hasPending`,
   `lastSync`, `online`, `active`, `error`, `rejectedWrite`, `roleOf`, `revokedIds`,
-  `forceResync`, `signOut`.
+  `forceResync`, `signOut`. Each collection replicates on its own; a container created in or moved to
+  the cloud (`createContainer`, `makeCloud`) holds its other rows back until its own row has reached
+  Supabase (`expectNewContainer`, at most 20 s), so row level security doesn't refuse them.
 - `ops`: container operations (`createContainer`, `renameContainer`, `makeCloud`, `makeLocal`,
   `deleteContainer`, `leaveContainer`, `keepRevokedCopy`, `removeRevoked`, `entries`,
   `exportContainers`, `importContainers`) and the row

package/dist/app.svelte.d.ts

@@ -4,7 +4,7 @@ import type { DocMap, Location } from './types.js';
  * Holds the two data sets: `local` (this device only, never synced) is always open;
  * `cloud` exists only while signed in and replicates to Supabase.
  */
-export declare class AppState<D extends DocMap> {
+export declare class AppState<D extends DocMap<D>> {
     local: DataSet<D> | null;
     cloud: DataSet<D> | null;
     ready: boolean;

package/dist/cloud.svelte.d.ts

@@ -10,7 +10,7 @@ export declare function isRejection(err: unknown): boolean;
  * 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> {
+export interface CloudSyncOptions<D extends DocMap<D>> {
     /** Prefix for database names and localStorage keys, e.g. 'demo'. */
     appKey: string;
     schema: StoreSchema<D>;
@@ -25,7 +25,7 @@ export interface CloudSyncOptions<D extends DocMap> {
  * pending changes per container (cleared once replication settles), last sync time, blocked
  * containers, membership / revocation checks, cached roles and rejected writes.
  */
-export declare class CloudSync<D extends DocMap> {
+export declare class CloudSync<D extends DocMap<D>> {
     #private;
     readonly configured: boolean;
     user: User | null;
@@ -56,6 +56,14 @@ export declare class CloudSync<D extends DocMap> {
     /** Record our role right away (e.g. after creating a container or changing roles). */
     setRole(containerId: string, role: Role): void;
     init(): Promise<void>;
+    /**
+     * Hold back a new cloud container's other rows until the container's own row has reached
+     * Supabase. Each collection replicates on its own, and the server only accepts a child row once
+     * its container exists (row level security checks the membership the container insert
+     * creates); without this, a container copied to the cloud with its rows has some of them
+     * rejected until the next retry.
+     */
+    expectNewContainer(containerId: string): void;
     /** Record that a container has local changes that still need to reach Supabase. */
     markPending(containerId: string): void;
     clearPending(containerId: string): void;

package/dist/cloud.svelte.js

@@ -7,6 +7,8 @@ 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;
+/** Longest a new container's other rows wait for the container row to be pushed. */
+const CONTAINER_WAIT_MS = 20_000;
 /** Push errors caused by the server refusing the write (RLS, triggers), not by connectivity. */
 export function isRejection(err) {
     const e = err;
@@ -65,6 +67,9 @@ export class CloudSync {
     #signingOut = false;
     #queue = Promise.resolve();
     #attached = null;
+    /** New cloud containers whose own row hasn't reached Supabase yet (see `expectNewContainer`). */
+    #unsent = new Map();
+    #unsentWaits = new Map();
     constructor(options) {
         this.#appKey = options.appKey;
         this.#schema = options.schema;
@@ -185,10 +190,40 @@ export class CloudSync {
         await this.#startReplication(db);
         this.#scheduleSettle();
     }
+    /**
+     * Hold back a new cloud container's other rows until the container's own row has reached
+     * Supabase. Each collection replicates on its own, and the server only accepts a child row once
+     * its container exists (row level security checks the membership the container insert
+     * creates); without this, a container copied to the cloud with its rows has some of them
+     * rejected until the next retry.
+     */
+    expectNewContainer(containerId) {
+        if (this.#unsent.has(containerId))
+            return;
+        let release;
+        const sent = new Promise((resolve) => (release = resolve));
+        this.#unsent.set(containerId, release);
+        this.#unsentWaits.set(containerId, sent);
+    }
+    #containerSent(containerId) {
+        this.#unsent.get(containerId)?.();
+        this.#unsent.delete(containerId);
+        this.#unsentWaits.delete(containerId);
+    }
+    /** Waits while the container's own row is still on its way (bounded: if it's refused, the server decides). */
+    async #afterContainer(containerId) {
+        const sent = this.#unsentWaits.get(containerId);
+        if (!sent)
+            return;
+        let timer;
+        await Promise.race([sent, new Promise((r) => (timer = setTimeout(r, CONTAINER_WAIT_MS)))]);
+        clearTimeout(timer);
+    }
     async #startReplication(db) {
         const { replicateSupabase } = await import('rxdb/plugins/replication-supabase');
         const sb = replicationClient(this.#sb.getClient(), this.#sb.schema);
         this.#schema.collections.forEach((name, index) => {
+            const isContainer = name === this.#schema.container;
             const rep = replicateSupabase({
                 replicationIdentifier: `supabase-${name}`,
                 client: sb,
@@ -201,7 +236,14 @@ export class CloudSync {
                 pull: { batchSize: 200 },
                 push: {
                     batchSize: 50,
-                    modifier: (doc) => this.#state.value.blocked.includes(containerIdOf(this.#schema, name, doc)) ? null : doc
+                    modifier: async (doc) => {
+                        const containerId = containerIdOf(this.#schema, name, doc);
+                        if (this.#state.value.blocked.includes(containerId))
+                            return null;
+                        if (!isContainer)
+                            await this.#afterContainer(containerId);
+                        return doc;
+                    }
                 }
             });
             this.#replications.push(rep);
@@ -218,7 +260,11 @@ export class CloudSync {
                 else
                     this.#activeReps.delete(index);
                 this.active = this.#activeReps.size > 0;
-            }), rep.received$.subscribe(() => this.#scheduleSettle()), rep.sent$.subscribe(() => this.#scheduleSettle()));
+            }), rep.received$.subscribe(() => this.#scheduleSettle()), rep.sent$.subscribe((doc) => {
+                if (isContainer)
+                    this.#containerSent(doc.id);
+                this.#scheduleSettle();
+            }));
         });
     }
     async #teardown(removeData) {
@@ -230,6 +276,8 @@ export class CloudSync {
         this.#replications = [];
         this.#activeReps.clear();
         this.active = false;
+        for (const id of [...this.#unsent.keys()])
+            this.#containerSent(id);
         await Promise.allSettled(reps.map((r) => r.cancel()));
         const ds = this.#app.cloud;
         this.#app.cloud = null;

package/dist/containers.d.ts

@@ -7,7 +7,7 @@ import type { SupabaseApi } from './supabase.js';
 import type { Tombstones } from './tombstones.svelte.js';
 import type { CollectionName, DocMap, Location, Role, StoreSchema } from './types.js';
 /** Every row of one container, by collection. */
-export type ContainerDocs<D extends DocMap> = {
+export type ContainerDocs<D extends DocMap<D>> = {
     [N in CollectionName<D>]: D[N][];
 };
 /**
@@ -15,8 +15,8 @@ export type ContainerDocs<D extends DocMap> = {
  * `refs` fields: composite ids and ids inside text fields. `map` turns an old id into the copy's
  * id (the identity when ids are kept).
  */
-export type RemapHook<D extends DocMap> = <N extends CollectionName<D>>(collection: N, row: D[N], map: (id: string) => string) => D[N];
-export interface ContainerOpsOptions<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> {
+export type RemapHook<D extends DocMap<D>> = <N extends CollectionName<D>>(collection: N, row: D[N], map: (id: string) => string) => D[N];
+export interface ContainerOpsOptions<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>> {
     schema: StoreSchema<D, C>;
     app: AppState<D>;
     cloud: CloudSync<D>;
@@ -57,12 +57,12 @@ export interface ContainerExport {
 }
 export declare const now: () => number;
 export declare const uid: () => `${string}-${string}-${string}-${string}-${string}`;
-export type ContainerOps<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> = ReturnType<typeof createContainerOps<D, C>>;
+export type ContainerOps<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>> = ReturnType<typeof createContainerOps<D, C>>;
 /**
  * Operations on whole containers and the low-level row helpers they're built from. Every write
  * to a cloud data set marks the container pending so the profile can show unsynced changes.
  */
-export declare function createContainerOps<D extends DocMap, C extends CollectionName<D> = CollectionName<D>>(options: ContainerOpsOptions<D, C>): {
+export declare function createContainerOps<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>>(options: ContainerOpsOptions<D, C>): {
     rx: <N extends CollectionName<D>>(ds: DataSet<D>, name: N) => RxCollection<D[N]>;
     touch: (ds: DataSet<D>, containerId: string) => void;
     removeDocs: <N extends CollectionName<D>>(ds: DataSet<D>, name: N, ids: string[]) => Promise<void>;

package/dist/containers.js

@@ -67,9 +67,11 @@ export function createContainerOps(options) {
         const t = now();
         const hasCreatedAt = 'created_at' in (schema.schemas[container].properties ?? {});
         const doc = { ...fields, id, updated_at: t, ...(hasCreatedAt ? { created_at: t } : {}) };
-        insertDoc(ds, container, doc, id);
-        if (ds.location === 'cloud')
+        if (ds.location === 'cloud') {
             cloud.setRole(id, 'owner');
+            cloud.expectNewContainer(id);
+        }
+        insertDoc(ds, container, doc, id);
         return id;
     }
     function renameContainer(ds, containerId, name) {
@@ -139,6 +141,7 @@ export function createContainerOps(options) {
         if (to.location === 'cloud') {
             cloud.markPending(cid);
             cloud.setRole(cid, 'owner');
+            cloud.expectNewContainer(cid);
         }
         // Rows deliberately written again (e.g. a container moved back here) must not stay hidden.
         for (const name of collections)

package/dist/database.d.ts

@@ -1,9 +1,9 @@
 import { type RxCollection, type RxConflictHandler, type RxDatabase, type RxStorage } from 'rxdb/plugins/core';
 import type { CollectionName, DocMap, StoreSchema } from './types.js';
-export type Collections<D extends DocMap> = {
+export type Collections<D extends DocMap<D>> = {
     [N in CollectionName<D>]: RxCollection<D[N]>;
 };
-export type Database<D extends DocMap> = RxDatabase<Collections<D>>;
+export type Database<D extends DocMap<D>> = RxDatabase<Collections<D>>;
 export declare function docsEqual(a: Record<string, unknown>, b: Record<string, unknown>): boolean;
 /**
  * Last write wins: whichever side carries the newer `updated_at` (client clock) is kept.
@@ -21,4 +21,4 @@ export interface OpenDatabaseOptions {
     multiInstance?: boolean;
 }
 /** Create an RxDB database with one collection per schema, all using last-write-wins. */
-export declare function openDatabase<D extends DocMap>(name: string, schema: Pick<StoreSchema<D>, 'collections' | 'schemas'>, { storage, multiInstance }?: OpenDatabaseOptions): Promise<Database<D>>;
+export declare function openDatabase<D extends DocMap<D>>(name: string, schema: Pick<StoreSchema<D>, 'collections' | 'schemas'>, { storage, multiInstance }?: OpenDatabaseOptions): Promise<Database<D>>;

package/dist/dataset.d.ts

@@ -7,12 +7,12 @@ export type TSCollection<T extends object> = ReturnType<typeof makeCollection<T>
  * One RxDB database plus a TanStack DB collection on top of each RxDB collection.
  * Components query the TanStack collections; bulk operations go straight to RxDB.
  */
-export type DataSet<D extends DocMap> = {
+export type DataSet<D extends DocMap<D>> = {
     location: Location;
     db: Database<D>;
 } & {
     [N in CollectionName<D>]: TSCollection<D[N]>;
 };
-export declare function createDataSet<D extends DocMap>(location: Location, db: Database<D>, schema: Pick<StoreSchema<D>, 'collections' | 'container' | 'containerField' | 'indexContainerField'>): DataSet<D>;
-export declare function disposeDataSet<D extends DocMap>(ds: DataSet<D>, collections: readonly CollectionName<D>[]): Promise<void>;
+export declare function createDataSet<D extends DocMap<D>>(location: Location, db: Database<D>, schema: Pick<StoreSchema<D>, 'collections' | 'container' | 'containerField' | 'indexContainerField'>): DataSet<D>;
+export declare function disposeDataSet<D extends DocMap<D>>(ds: DataSet<D>, collections: readonly CollectionName<D>[]): Promise<void>;
 export {};

package/dist/store.d.ts

@@ -12,7 +12,7 @@ import type { CollectionName, DocMap, Nouns, StoreSchema } from './types.js';
  * `C` is the container collection; pass it (`createSyncedStore<Docs, 'projects'>`) so container
  * rows are typed as that document rather than a union of every document.
  */
-export interface SyncedStoreConfig<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> extends StoreSchema<D, C> {
+export interface SyncedStoreConfig<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>> extends StoreSchema<D, C> {
     /** Prefix for database names and localStorage keys, e.g. 'demo' → `demo_local`, `demo:hidden`. */
     appKey: string;
     nouns: Nouns;
@@ -56,7 +56,7 @@ export interface SyncedStoreConfig<D extends DocMap, C extends CollectionName<D>
  * sets), cloud sync, tombstones, device prefs, the Supabase members API and container
  * operations. Create it once in a module and import it where needed.
  */
-export declare function createSyncedStore<D extends DocMap, C extends CollectionName<D> = CollectionName<D>>(config: SyncedStoreConfig<D, C>): {
+export declare function createSyncedStore<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>>(config: SyncedStoreConfig<D, C>): {
     config: SyncedStoreConfig<D, C>;
     roles: boolean;
     app: AppState<D>;
@@ -100,4 +100,4 @@ export declare function createSyncedStore<D extends DocMap, C extends Collection
     resetDevice: () => Promise<void>;
     requestPersistence: () => Promise<boolean | null>;
 };
-export type SyncedStore<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> = ReturnType<typeof createSyncedStore<D, C>>;
+export type SyncedStore<D extends DocMap<D>, C extends CollectionName<D> = CollectionName<D>> = ReturnType<typeof createSyncedStore<D, C>>;

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.2",
+  "version": "1.1.0",
   "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": {