@kubun/store-p2p 0.18.1 → 0.20.0

package/lib/ops/app-lane.js

@@ -1,3 +1,5 @@
+import { withStoreTransaction } from '@kubun/db';
+import { decodeJSON } from '@kubun/db-adapter';
 import { sortPendingAppFrames } from '@kumiai/rpc';
 import { createMLSOps } from './mls.js';
 export function createAppLaneOps(db, adapter) {
@@ -5,7 +7,7 @@ export function createAppLaneOps(db, adapter) {
         async saveOpenedAppFrame ({ state, expected, record }) {
             const save = async (tx)=>{
                 if (!await createMLSOps(tx, adapter).saveMLSState(state, expected)) return false;
-                await tx.insertInto('kubun_p2p_app_pending').values({
+                await tx.insertInto('p2p_app_pending').values({
                     group_id: state.group_id,
                     device_id: state.device_id,
                     frame_id: record.frameID,
@@ -22,10 +24,10 @@ export function createAppLaneOps(db, adapter) {
                     ]).doNothing()).execute();
                 return true;
             };
-            return db.isTransaction ? await save(db) : await db.transaction().execute(save);
+            return await withStoreTransaction(db, save);
         },
         async listPendingAppFrames (groupID, deviceID) {
-            const rows = await db.selectFrom('kubun_p2p_app_pending').selectAll().where('group_id', '=', groupID).where('device_id', '=', deviceID).execute();
+            const rows = await db.selectFrom('p2p_app_pending').selectAll().where('group_id', '=', groupID).where('device_id', '=', deviceID).execute();
             const sorted = sortPendingAppFrames(rows.map((row)=>({
                     frame: {
                         id: row.frame_id,
@@ -41,15 +43,15 @@ export function createAppLaneOps(db, adapter) {
             return sorted.map(({ row })=>row);
         },
         async completePendingAppFrame (groupID, deviceID, frameID) {
-            await db.deleteFrom('kubun_p2p_app_pending').where('group_id', '=', groupID).where('device_id', '=', deviceID).where('frame_id', '=', frameID).execute();
+            await db.deleteFrom('p2p_app_pending').where('group_id', '=', groupID).where('device_id', '=', deviceID).where('frame_id', '=', frameID).execute();
         },
         async deleteGroupAppLane (groupID, deviceID) {
             const remove = async (tx)=>{
-                await tx.deleteFrom('kubun_p2p_app_pending').where('group_id', '=', groupID).where('device_id', '=', deviceID).execute();
-                await tx.deleteFrom('kubun_p2p_group_anchor').where('group_id', '=', groupID).execute();
-                await tx.deleteFrom('kubun_p2p_app_cursor').where('group_id', '=', groupID).execute();
+                await tx.deleteFrom('p2p_app_pending').where('group_id', '=', groupID).where('device_id', '=', deviceID).execute();
+                await tx.deleteFrom('p2p_group_anchor').where('group_id', '=', groupID).execute();
+                await tx.deleteFrom('p2p_app_cursor').where('group_id', '=', groupID).execute();
             };
-            return db.isTransaction ? await remove(db) : await db.transaction().execute(remove);
+            return await withStoreTransaction(db, remove);
         },
         async putGroupAnchor (params) {
             const values = {
@@ -58,7 +60,7 @@ export function createAppLaneOps(db, adapter) {
                 epoch: params.epoch,
                 pending: params.pending == null ? null : adapter.encodeJSON(params.pending)
             };
-            await db.insertInto('kubun_p2p_group_anchor')// Single slot per group: a rotation REPLACES both halves together. The
+            await db.insertInto('p2p_group_anchor')// Single slot per group: a rotation REPLACES both halves together. The
             // secret and the epoch it was exported at both feed topic derivation,
             // so a row mixing one epoch's secret with another's number would derive
             // a topic no member is on.
@@ -69,11 +71,15 @@ export function createAppLaneOps(db, adapter) {
                     }))).execute();
         },
         async getGroupAnchor (groupID) {
-            return await db.selectFrom('kubun_p2p_group_anchor').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            const row = await db.selectFrom('p2p_group_anchor').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            return row == null ? undefined : {
+                ...row,
+                pending: decodeJSON(adapter.kind, row.pending)
+            };
         },
         // --- App-lane cursor operations ---
         async putAppCursor (params) {
-            await db.insertInto('kubun_p2p_app_cursor').values({
+            await db.insertInto('p2p_app_cursor').values({
                 group_id: params.groupID,
                 topic_id: params.topicID,
                 position: params.position
@@ -85,7 +91,7 @@ export function createAppLaneOps(db, adapter) {
                     }))).execute();
         },
         async getAppCursor (params) {
-            return await db.selectFrom('kubun_p2p_app_cursor').selectAll().where('group_id', '=', params.groupID).where('topic_id', '=', params.topicID).executeTakeFirst();
+            return await db.selectFrom('p2p_app_cursor').selectAll().where('group_id', '=', params.groupID).where('topic_id', '=', params.topicID).executeTakeFirst();
         }
     };
 }

package/lib/ops/app-outbox.d.ts

@@ -1,4 +1,5 @@
-import type { Adapter } from '@kubun/db-adapter';
+import type { StoreAPIContext } from '@kubun/db';
+import { type Adapter } from '@kubun/db-adapter';
 import { type AppOutbox } from '@kumiai/rpc';
 import type { Runtime } from '@sozai/runtime';
 import type { Kysely } from 'kysely';
@@ -41,4 +42,5 @@ export type AppOutboxOps = {
 export declare function lockAppOutboxForErasure(db: Kysely<P2PStoreTables>, groupID: string, options?: ClearAppOutboxRowsOptions): Promise<void>;
 /** The caller's transaction also covers group leave or deletion. */
 export declare function clearAppOutboxRows(db: Kysely<P2PStoreTables>, groupID: string, options?: ClearAppOutboxRowsOptions): Promise<Array<number>>;
-export declare function createAppOutboxOps(db: Kysely<P2PStoreTables>, adapter: Adapter, getRandomValues: Runtime['getRandomValues']): AppOutboxOps;
+export declare function withAppOutboxLock<R>(context: StoreAPIContext, groupID: string, run: (tx: Kysely<P2PStoreTables>) => Promise<R>): Promise<R>;
+export declare function createAppOutboxOps(db: Kysely<P2PStoreTables>, adapter: Adapter, getRandomValues: Runtime['getRandomValues'], context: StoreAPIContext): AppOutboxOps;

package/lib/ops/app-outbox.js

@@ -1,6 +1,8 @@
 import { encodeMultibase, multihashSHA256 } from '@kokuin/token';
+import { decodeJSON } from '@kubun/db-adapter';
 import { AppEntryTooLargeError, AppOutboxFullError, MAX_APP_ENTRY_BYTES, SendNotAdmissibleError } from '@kumiai/rpc';
 import { gcm } from '@noble/ciphers/aes.js';
+import { withP2PKeyLocks } from '../scope.js';
 const KEY_LENGTH = 32;
 const IV_LENGTH = 12;
 export class AppOutboxDecryptionError extends Error {
@@ -55,18 +57,12 @@ function associatedData(groupID, entry) {
     ]));
 }
 async function hasUndeliveredRevocations(db, groupID) {
-    const marker = await db.selectFrom('kubun_p2p_group_delegation').select('jti').where('group_id', '=', groupID).where('pending_revocation_hlc', 'is not', null).limit(1).executeTakeFirst();
+    const marker = await db.selectFrom('p2p_group_delegation').select('jti').where('group_id', '=', groupID).where('pending_revocation_hlc', 'is not', null).limit(1).executeTakeFirst();
     if (marker != null) return true;
-    const queued = await db.selectFrom('kubun_p2p_app_outbox').select('seq').where('group_id', '=', groupID).where('protocol', '=', 'control').where('prc', '=', 'control/delegationRevoke').limit(1).executeTakeFirst();
+    const queued = await db.selectFrom('p2p_app_outbox').select('seq').where('group_id', '=', groupID).where('protocol', '=', 'control').where('prc', '=', 'control/delegationRevoke').limit(1).executeTakeFirst();
     return queued != null;
 }
 /** Coordinate status transitions with revocation admission and outbox erasure. */ export async function lockAppOutboxForErasure(db, groupID, options) {
-    // Lock first-write creation too, even when the group has never held a key.
-    await db.insertInto('kubun_p2p_app_outbox_state').values({
-        group_id: groupID
-    }).onConflict((oc)=>oc.column('group_id').doUpdateSet({
-            group_id: groupID
-        })).execute();
     // Under the erasure lock: a revocation committed after the leaver's delivery
     // check is either seen here or blocks until this transaction ends.
     if (options?.requireRevocationsDelivered === true && await hasUndeliveredRevocations(db, groupID)) {
@@ -75,23 +71,29 @@ async function hasUndeliveredRevocations(db, groupID) {
 }
 /** The caller's transaction also covers group leave or deletion. */ export async function clearAppOutboxRows(db, groupID, options) {
     await lockAppOutboxForErasure(db, groupID, options);
-    await db.updateTable('kubun_p2p_group_delegation').set({
+    await db.updateTable('p2p_group_delegation').set({
         pending_grant_hlc: null,
         pending_grant_digest: null,
         pending_revocation_hlc: null,
         pending_revocation_digest: null
     }).where('group_id', '=', groupID).execute();
-    await db.deleteFrom('kubun_p2p_app_outbox_state').where('group_id', '=', groupID).execute();
-    const deleted = await db.deleteFrom('kubun_p2p_app_outbox').where('group_id', '=', groupID).returning('seq').execute();
+    await db.deleteFrom('p2p_app_outbox_state').where('group_id', '=', groupID).execute();
+    const deleted = await db.deleteFrom('p2p_app_outbox').where('group_id', '=', groupID).returning('seq').execute();
     return deleted.map((entry)=>entry.seq).sort((a, b)=>a - b);
 }
-export function createAppOutboxOps(db, adapter, getRandomValues) {
+export async function withAppOutboxLock(context, groupID, run) {
+    return await withP2PKeyLocks(context, 'p2p_app_outbox_state', [
+        [
+            groupID
+        ]
+    ], run);
+}
+export function createAppOutboxOps(db, adapter, getRandomValues, context) {
     const clearAppOutbox = async (groupID)=>{
         const clear = async (tx)=>{
             await clearAppOutboxRows(tx, groupID);
         };
-        if (db.isTransaction) await clear(db);
-        else await db.transaction().execute(clear);
+        await withAppOutboxLock(context, groupID, clear);
     };
     return {
         clearAppOutbox,
@@ -107,30 +109,28 @@ export function createAppOutboxOps(db, adapter, getRandomValues) {
                     }
                     const admission = pendingDelegationAdmission(entry);
                     const put = async (tx)=>{
-                        // The upsert locks the key row against concurrent crypto-erasure.
-                        const state = await tx.insertInto('kubun_p2p_app_outbox_state').values({
+                        await tx.insertInto('p2p_app_outbox_state').values({
                             group_id: groupID
-                        }).onConflict((oc)=>oc.column('group_id').doUpdateSet({
-                                group_id: groupID
-                            })).returning('key').executeTakeFirstOrThrow();
+                        }).onConflict((oc)=>oc.column('group_id').doNothing()).execute();
+                        const state = await tx.selectFrom('p2p_app_outbox_state').select('key').where('group_id', '=', groupID).executeTakeFirstOrThrow();
                         // Check after acquiring the erasure lock: a put resumed after removal
                         // must not recreate the destroyed key or an encrypted outbox row.
-                        const group = await tx.selectFrom('kubun_p2p_groups').select('status').where('id', '=', groupID).executeTakeFirst();
+                        const group = await tx.selectFrom('p2p_groups').select('status').where('id', '=', groupID).executeTakeFirst();
                         if (group?.status === 'left' || admission != null && group?.status !== 'joined') {
                             throw new SendNotAdmissibleError('lapsed');
                         }
                         if (admission?.kind !== 'revocation') {
-                            const accepted = await tx.selectFrom('kubun_p2p_app_outbox').select('seq').where('group_id', '=', groupID).where('seq', '=', entry.seq).executeTakeFirst();
+                            const accepted = await tx.selectFrom('p2p_app_outbox').select('seq').where('group_id', '=', groupID).where('seq', '=', entry.seq).executeTakeFirst();
                             // Accepted entries must stay writable so draining can release capacity.
                             if (accepted == null) {
-                                const pendingRevocation = await tx.selectFrom('kubun_p2p_group_delegation').select('jti').where('group_id', '=', groupID).where('pending_revocation_hlc', 'is not', null).limit(1).executeTakeFirst();
+                                const pendingRevocation = await tx.selectFrom('p2p_group_delegation').select('jti').where('group_id', '=', groupID).where('pending_revocation_hlc', 'is not', null).limit(1).executeTakeFirst();
                                 if (pendingRevocation != null && admission?.kind === 'grant') {
                                     throw new PendingRevocationAdmissionError('Pending revocations must be admitted before new grants');
                                 }
                                 if (pendingRevocation != null && options?.limit != null) {
                                     // Other retained traffic leaves the last slot to revocations, so a
                                     // revocation that cannot be admitted never holds presence back.
-                                    const queued = await tx.selectFrom('kubun_p2p_app_outbox').select((eb)=>eb.fn.countAll().as('count')).where('group_id', '=', groupID).executeTakeFirstOrThrow();
+                                    const queued = await tx.selectFrom('p2p_app_outbox').select((eb)=>eb.fn.countAll().as('count')).where('group_id', '=', groupID).executeTakeFirstOrThrow();
                                     if (Number(queued.count) >= options.limit - 1) {
                                         throw new AppOutboxFullError('App outbox slot reserved for revocations');
                                     }
@@ -140,13 +140,13 @@ export function createAppOutboxOps(db, adapter, getRandomValues) {
                         let key = state.key;
                         if (key == null) {
                             key = getRandomValues(new Uint8Array(KEY_LENGTH));
-                            await tx.updateTable('kubun_p2p_app_outbox_state').set({
+                            await tx.updateTable('p2p_app_outbox_state').set({
                                 key: adapter.encodeBinary(key)
                             }).where('group_id', '=', groupID).execute();
                         }
                         const iv = getRandomValues(new Uint8Array(IV_LENGTH));
                         const data = gcm(key, iv, associatedData(groupID, entry)).encrypt(entry.data);
-                        await tx.insertInto('kubun_p2p_app_outbox').values({
+                        await tx.insertInto('p2p_app_outbox').values({
                             group_id: groupID,
                             seq: entry.seq,
                             protocol: entry.protocol,
@@ -168,7 +168,7 @@ export function createAppOutboxOps(db, adapter, getRandomValues) {
                             const hlcColumn = admission.kind === 'grant' ? 'pending_grant_hlc' : 'pending_revocation_hlc';
                             const digestColumn = admission.kind === 'grant' ? 'pending_grant_digest' : 'pending_revocation_digest';
                             // Admission and marker clear commit together, matching the exact stored token.
-                            await tx.updateTable('kubun_p2p_group_delegation').set(admission.kind === 'grant' ? {
+                            await tx.updateTable('p2p_group_delegation').set(admission.kind === 'grant' ? {
                                 pending_grant_hlc: null,
                                 pending_grant_digest: null
                             } : {
@@ -177,10 +177,10 @@ export function createAppOutboxOps(db, adapter, getRandomValues) {
                             }).where('group_id', '=', groupID).where(hlcColumn, '=', admission.hlc).where(digestColumn, '=', admission.digest).execute();
                         }
                     };
-                    await db.transaction().execute(put);
+                    await withAppOutboxLock(context, groupID, put);
                 },
                 async list () {
-                    const rows = await db.selectFrom('kubun_p2p_app_outbox as entry').leftJoin('kubun_p2p_app_outbox_state as state', 'state.group_id', 'entry.group_id').select([
+                    const rows = await db.selectFrom('p2p_app_outbox as entry').leftJoin('p2p_app_outbox_state as state', 'state.group_id', 'entry.group_id').select([
                         'entry.seq',
                         'entry.protocol',
                         'entry.prc',
@@ -194,7 +194,7 @@ export function createAppOutboxOps(db, adapter, getRandomValues) {
                             seq: row.seq,
                             protocol: row.protocol,
                             prc: row.prc,
-                            lastAttempt: row.last_attempt
+                            lastAttempt: decodeJSON(adapter.kind, row.last_attempt)
                         };
                         if (row.key == null) {
                             throw new AppOutboxDecryptionError(`App outbox key is absent for group ${groupID}`);
@@ -213,17 +213,17 @@ export function createAppOutboxOps(db, adapter, getRandomValues) {
                     });
                 },
                 async remove (seq) {
-                    await db.deleteFrom('kubun_p2p_app_outbox').where('group_id', '=', groupID).where('seq', '=', seq).execute();
+                    await db.deleteFrom('p2p_app_outbox').where('group_id', '=', groupID).where('seq', '=', seq).execute();
                 },
                 clear: ()=>clearAppOutbox(groupID),
                 async getCommitCursor () {
-                    const state = await db.selectFrom('kubun_p2p_app_outbox_state').select('commit_cursor').where('group_id', '=', groupID).executeTakeFirst();
-                    return state?.commit_cursor ?? null;
+                    const state = await db.selectFrom('p2p_app_outbox_state').select('commit_cursor').where('group_id', '=', groupID).executeTakeFirst();
+                    return decodeJSON(adapter.kind, state?.commit_cursor);
                 },
                 async putCommitCursor (cursor) {
                     // A write after clear can recreate a key-less row with a stale cursor.
                     // Kumiai resets that cursor when rejoin changes the epoch.
-                    await db.insertInto('kubun_p2p_app_outbox_state').values({
+                    await db.insertInto('p2p_app_outbox_state').values({
                         group_id: groupID,
                         commit_cursor: cursor == null ? null : adapter.encodeJSON(cursor)
                     }).onConflict((oc)=>oc.column('group_id').doUpdateSet((eb)=>({

package/lib/ops/catalog-offers.d.ts

@@ -1,4 +1,4 @@
-import { type Kysely } from 'kysely';
+import type { Kysely } from 'kysely';
 import type { P2PStoreTables } from '../tables.js';
 export type CatalogOffer = {
     owner: string;

package/lib/ops/catalog-offers.js

@@ -1,4 +1,4 @@
-import { Transaction } from 'kysely';
+import { withStoreTransaction } from '@kubun/db';
 export function createCatalogOfferOps(db) {
     const project = (row)=>({
             owner: row.owner,
@@ -9,7 +9,7 @@ export function createCatalogOfferOps(db) {
         });
     return {
         async putCatalogOffer (offer) {
-            await db.insertInto('kubun_p2p_catalog_offers').values({
+            await db.insertInto('p2p_catalog_offers').values({
                 owner: offer.owner,
                 exposure_id: offer.exposureID,
                 catalog_id: offer.catalogID,
@@ -25,20 +25,20 @@ export function createCatalogOfferOps(db) {
                 })).execute();
         },
         async removeCatalogOffer (owner, exposureID) {
-            await db.deleteFrom('kubun_p2p_catalog_offers').where('owner', '=', owner).where('exposure_id', '=', exposureID).execute();
+            await db.deleteFrom('p2p_catalog_offers').where('owner', '=', owner).where('exposure_id', '=', exposureID).execute();
         },
         async removeCatalogOffersForCatalog (owner, catalogID) {
-            await db.deleteFrom('kubun_p2p_catalog_offers').where('owner', '=', owner).where('catalog_id', '=', catalogID).execute();
+            await db.deleteFrom('p2p_catalog_offers').where('owner', '=', owner).where('catalog_id', '=', catalogID).execute();
         },
         async allCatalogOffers () {
-            return (await db.selectFrom('kubun_p2p_catalog_offers').selectAll().execute()).map(project);
+            return (await db.selectFrom('p2p_catalog_offers').selectAll().execute()).map(project);
         },
         async replaceCatalogOffers (groupID, offers) {
             if (offers.some((offer)=>offer.groupID !== groupID)) throw new Error('Catalog offer group does not match replacement scope');
             const replace = async (tx)=>{
-                await tx.deleteFrom('kubun_p2p_catalog_offers').where('group_id', '=', groupID).execute();
+                await tx.deleteFrom('p2p_catalog_offers').where('group_id', '=', groupID).execute();
                 if (offers.length === 0) return;
-                await tx.insertInto('kubun_p2p_catalog_offers').values(offers.map((offer)=>({
+                await tx.insertInto('p2p_catalog_offers').values(offers.map((offer)=>({
                         owner: offer.owner,
                         exposure_id: offer.exposureID,
                         catalog_id: offer.catalogID,
@@ -46,11 +46,10 @@ export function createCatalogOfferOps(db) {
                         circle_id: offer.circleID
                     }))).execute();
             };
-            if (db instanceof Transaction) await replace(db);
-            else await db.transaction().execute(replace);
+            await withStoreTransaction(db, replace);
         },
         async activeCatalogOffers (groupID, circleID) {
-            let query = db.selectFrom('kubun_p2p_catalog_offers').selectAll().where('group_id', '=', groupID);
+            let query = db.selectFrom('p2p_catalog_offers').selectAll().where('group_id', '=', groupID);
             if (circleID !== null) query = query.where('circle_id', '=', circleID);
             const rows = await query.orderBy('owner').orderBy('exposure_id').execute();
             return rows.map(project);

package/lib/ops/catalog-routes.js

@@ -9,10 +9,10 @@ export function createCatalogRouteOps(db) {
     return {
         async setCatalogRoute (owner, catalogID, groupID, pull, push) {
             if (!pull && !push) {
-                await db.deleteFrom('kubun_p2p_catalog_routes').where('owner', '=', owner).where('catalog_id', '=', catalogID).where('group_id', '=', groupID).execute();
+                await db.deleteFrom('p2p_catalog_routes').where('owner', '=', owner).where('catalog_id', '=', catalogID).where('group_id', '=', groupID).execute();
                 return;
             }
-            await db.insertInto('kubun_p2p_catalog_routes').values({
+            await db.insertInto('p2p_catalog_routes').values({
                 owner,
                 catalog_id: catalogID,
                 group_id: groupID,
@@ -28,33 +28,33 @@ export function createCatalogRouteOps(db) {
                 })).execute();
         },
         async getGroupServing ({ groupID }) {
-            const row = await db.selectFrom('kubun_p2p_unserved_groups').select('group_id').where('group_id', '=', groupID).executeTakeFirst();
+            const row = await db.selectFrom('p2p_unserved_groups').select('group_id').where('group_id', '=', groupID).executeTakeFirst();
             return row == null;
         },
         async setGroupServing ({ groupID, enabled }) {
             if (enabled) {
-                await db.deleteFrom('kubun_p2p_unserved_groups').where('group_id', '=', groupID).execute();
+                await db.deleteFrom('p2p_unserved_groups').where('group_id', '=', groupID).execute();
                 return;
             }
-            await db.insertInto('kubun_p2p_unserved_groups').values({
+            await db.insertInto('p2p_unserved_groups').values({
                 group_id: groupID
             }).onConflict((oc)=>oc.column('group_id').doNothing()).execute();
         },
         async catalogRoutes (owner, catalogID) {
-            const rows = await db.selectFrom('kubun_p2p_catalog_routes').selectAll().where('owner', '=', owner).where('catalog_id', '=', catalogID).orderBy('group_id').execute();
+            const rows = await db.selectFrom('p2p_catalog_routes').selectAll().where('owner', '=', owner).where('catalog_id', '=', catalogID).orderBy('group_id').execute();
             return rows.map(project);
         },
         async allCatalogRoutes (groupID) {
-            let query = db.selectFrom('kubun_p2p_catalog_routes').selectAll();
+            let query = db.selectFrom('p2p_catalog_routes').selectAll();
             if (groupID != null) query = query.where('group_id', '=', groupID);
             const rows = await query.orderBy('owner').orderBy('catalog_id').orderBy('group_id').execute();
             return rows.map(project);
         },
         async deleteCatalogRoutes (owner, catalogID) {
-            await db.deleteFrom('kubun_p2p_catalog_routes').where('owner', '=', owner).where('catalog_id', '=', catalogID).execute();
+            await db.deleteFrom('p2p_catalog_routes').where('owner', '=', owner).where('catalog_id', '=', catalogID).execute();
         },
         async deleteGroupCatalogRoutes (groupID) {
-            await db.deleteFrom('kubun_p2p_catalog_routes').where('group_id', '=', groupID).execute();
+            await db.deleteFrom('p2p_catalog_routes').where('group_id', '=', groupID).execute();
         }
     };
 }

package/lib/ops/catalog-sync.d.ts

@@ -1,3 +1,4 @@
+import type { StoreAPIContext } from '@kubun/db';
 import { type Adapter } from '@kubun/db-adapter';
 import type { Kysely } from 'kysely';
 import type { P2PStoreTables } from '../tables.js';
@@ -119,4 +120,4 @@ export type CatalogSyncOps = {
         limit: number;
     }): Promise<Array<string>>;
 };
-export declare function createCatalogSyncOps(db: Kysely<P2PStoreTables>, adapter: Adapter): CatalogSyncOps;
+export declare function createCatalogSyncOps(db: Kysely<P2PStoreTables>, adapter: Adapter, context: StoreAPIContext): CatalogSyncOps;

package/lib/ops/catalog-sync.js

@@ -1,5 +1,7 @@
-import { AbstractPostgresAdapter } from '@kubun/db-adapter';
+import { withStoreTransaction } from '@kubun/db';
+import { decodeJSON } from '@kubun/db-adapter';
 import { sql } from 'kysely';
+import { withP2PKeyLocks } from '../scope.js';
 /** Listed repair rows one peer may account for in one group; the oldest go first. */ export const MAX_REPAIRS_PER_LISTER = 10_000;
 function scheduleFromRow(row, triedPeers) {
     return {
@@ -10,14 +12,11 @@ function scheduleFromRow(row, triedPeers) {
         triedPeers
     };
 }
-/** Some adapters parse JSON text on read. */ function parseJSON(value) {
-    return typeof value === 'string' ? JSON.parse(value) : value;
-}
-export function createCatalogSyncOps(db, adapter) {
+export function createCatalogSyncOps(db, adapter, context) {
     const triedPeersOf = async (documentIDs, from = db)=>{
         const tried = new Map();
         if (documentIDs.length === 0) return tried;
-        const rows = await from.selectFrom('kubun_p2p_observation_repair_peers').selectAll().where('document_id', 'in', [
+        const rows = await from.selectFrom('p2p_observation_repair_peers').selectAll().where('document_id', 'in', [
             ...documentIDs
         ]).orderBy('peer_did').execute();
         for (const row of rows){
@@ -30,7 +29,7 @@ export function createCatalogSyncOps(db, adapter) {
     const readSchedules = async (from, documentIDs)=>{
         const schedules = new Map();
         if (documentIDs.length === 0) return schedules;
-        const rows = await from.selectFrom('kubun_p2p_observation_repairs').selectAll().where('document_id', 'in', [
+        const rows = await from.selectFrom('p2p_observation_repairs').selectAll().where('document_id', 'in', [
             ...documentIDs
         ]).execute();
         const tried = await triedPeersOf(rows.map((row)=>row.document_id), from);
@@ -49,29 +48,28 @@ export function createCatalogSyncOps(db, adapter) {
             next_attempt_at: schedule.nextAttemptAt,
             tried_count: triedPeers.length
         };
-        await tx.insertInto('kubun_p2p_observation_repairs').values({
+        await tx.insertInto('p2p_observation_repairs').values({
             document_id: schedule.documentID,
             ...values
         }).onConflict((oc)=>oc.column('document_id').doUpdateSet(values)).execute();
-        await tx.deleteFrom('kubun_p2p_observation_repair_peers').where('document_id', '=', schedule.documentID).execute();
+        await tx.deleteFrom('p2p_observation_repair_peers').where('document_id', '=', schedule.documentID).execute();
         if (triedPeers.length > 0) {
-            await tx.insertInto('kubun_p2p_observation_repair_peers').values(triedPeers.map((peerDID)=>({
+            await tx.insertInto('p2p_observation_repair_peers').values(triedPeers.map((peerDID)=>({
                     document_id: schedule.documentID,
                     peer_did: peerDID
                 }))).execute();
         }
     };
-    const inTransaction = async (fn)=>db.isTransaction ? await fn(db) : await db.transaction().execute(fn);
     const ops = {
         async getCatalogCursor (peerDID, groupID) {
-            const row = await db.selectFrom('kubun_p2p_catalog_cursors').selectAll().where('peer_did', '=', peerDID).where('group_id', '=', groupID).executeTakeFirst();
+            const row = await db.selectFrom('p2p_catalog_cursors').selectAll().where('peer_did', '=', peerDID).where('group_id', '=', groupID).executeTakeFirst();
             if (row == null) return null;
             return {
                 rulesHash: row.rules_hash,
                 cursor: row.last_key ?? null,
                 token: row.last_token ?? null,
                 cycleClear: Number(row.cycle_clear) === 1,
-                bounds: parseJSON(row.bounds)
+                bounds: decodeJSON(adapter.kind, row.bounds)
             };
         },
         async setCatalogCursor (peerDID, groupID, state) {
@@ -80,9 +78,9 @@ export function createCatalogSyncOps(db, adapter) {
                 last_key: state.cursor,
                 last_token: state.token,
                 cycle_clear: state.cycleClear ? 1 : 0,
-                bounds: JSON.stringify(state.bounds)
+                bounds: adapter.encodeJSON(state.bounds)
             };
-            await db.insertInto('kubun_p2p_catalog_cursors').values({
+            await db.insertInto('p2p_catalog_cursors').values({
                 peer_did: peerDID,
                 group_id: groupID,
                 ...values
@@ -98,8 +96,8 @@ export function createCatalogSyncOps(db, adapter) {
                 ...documentIDs
             ];
             const [found, answers] = await Promise.all([
-                db.selectFrom('kubun_p2p_document_repairs').selectAll().where('group_id', '=', groupID).where('document_id', 'in', ids).execute(),
-                db.selectFrom('kubun_p2p_document_repair_answers').selectAll().where('group_id', '=', groupID).where('document_id', 'in', ids).execute()
+                db.selectFrom('p2p_document_repairs').selectAll().where('group_id', '=', groupID).where('document_id', 'in', ids).execute(),
+                db.selectFrom('p2p_document_repair_answers').selectAll().where('group_id', '=', groupID).where('document_id', 'in', ids).execute()
             ]);
             for (const row of found){
                 rows.set(row.document_id, {
@@ -123,22 +121,22 @@ export function createCatalogSyncOps(db, adapter) {
             const listedBy = existing?.listedBy ?? (params.listed ? params.peerDID : null);
             if (params.listed && existing?.listedBy == null) {
                 // A peer that lists more than its share pushes out its own oldest rows.
-                const counted = await db.selectFrom('kubun_p2p_document_repairs').select((eb)=>eb.fn.countAll().as('count')).where('group_id', '=', groupID).where('listed_by', '=', params.peerDID).executeTakeFirst();
+                const counted = await db.selectFrom('p2p_document_repairs').select((eb)=>eb.fn.countAll().as('count')).where('group_id', '=', groupID).where('listed_by', '=', params.peerDID).executeTakeFirst();
                 const excess = Number(counted?.count ?? 0) + 1 - MAX_REPAIRS_PER_LISTER;
                 if (excess > 0) {
-                    const oldest = await db.selectFrom('kubun_p2p_document_repairs').select('document_id').where('group_id', '=', groupID).where('listed_by', '=', params.peerDID).orderBy('attempted_at').orderBy('document_id').limit(excess).execute();
+                    const oldest = await db.selectFrom('p2p_document_repairs').select('document_id').where('group_id', '=', groupID).where('listed_by', '=', params.peerDID).orderBy('attempted_at').orderBy('document_id').limit(excess).execute();
                     await ops.resolveDocumentRepairs(groupID, oldest.map((row)=>row.document_id));
                 }
             }
             if (existing != null && existing.holdingsDigest !== params.holdingsDigest) {
-                await db.deleteFrom('kubun_p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', '=', documentID).execute();
+                await db.deleteFrom('p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', '=', documentID).execute();
             }
             const values = {
                 listed_by: listedBy,
                 holdings_digest: params.holdingsDigest,
                 attempted_at: params.attemptedAt
             };
-            await db.insertInto('kubun_p2p_document_repairs').values({
+            await db.insertInto('p2p_document_repairs').values({
                 group_id: groupID,
                 document_id: documentID,
                 created_at: existing?.createdAt ?? params.attemptedAt,
@@ -148,12 +146,12 @@ export function createCatalogSyncOps(db, adapter) {
                     'document_id'
                 ]).doUpdateSet({
                     ...values,
-                    listed_by: sql`coalesce(kubun_p2p_document_repairs.listed_by, ${listedBy})`
+                    listed_by: sql`coalesce(${sql.ref('p2p_document_repairs.listed_by')}, ${listedBy})`
                 })).execute();
             if (params.answer == null) {
-                await db.deleteFrom('kubun_p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', '=', documentID).where('peer_did', '=', params.peerDID).execute();
+                await db.deleteFrom('p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', '=', documentID).where('peer_did', '=', params.peerDID).execute();
             } else {
-                await db.insertInto('kubun_p2p_document_repair_answers').values({
+                await db.insertInto('p2p_document_repair_answers').values({
                     group_id: groupID,
                     document_id: documentID,
                     peer_did: params.peerDID,
@@ -170,8 +168,8 @@ export function createCatalogSyncOps(db, adapter) {
         async resolveDocumentRepairs (groupID, documentIDs) {
             if (documentIDs.length === 0) return;
             for (const table of [
-                'kubun_p2p_document_repair_answers',
-                'kubun_p2p_document_repairs'
+                'p2p_document_repair_answers',
+                'p2p_document_repairs'
             ]){
                 await db.deleteFrom(table).where('group_id', '=', groupID).where('document_id', 'in', [
                     ...documentIDs
@@ -179,22 +177,22 @@ export function createCatalogSyncOps(db, adapter) {
             }
         },
         async listDocumentRepairs (groupID, peerDID, limit) {
-            const rows = await db.selectFrom('kubun_p2p_document_repairs as r').select('r.document_id').where('r.group_id', '=', groupID).where('r.listed_by', 'is not', null).where(({ not, exists, selectFrom })=>not(exists(selectFrom('kubun_p2p_document_repair_answers as a').select('a.peer_did').whereRef('a.group_id', '=', 'r.group_id').whereRef('a.document_id', '=', 'r.document_id').where('a.peer_did', '=', peerDID)))).orderBy('r.attempted_at').orderBy('r.document_id').limit(limit).execute();
+            const rows = await db.selectFrom('p2p_document_repairs as r').select('r.document_id').where('r.group_id', '=', groupID).where('r.listed_by', 'is not', null).where(({ not, exists, selectFrom })=>not(exists(selectFrom('p2p_document_repair_answers as a').select('a.peer_did').whereRef('a.group_id', '=', 'r.group_id').whereRef('a.document_id', '=', 'r.document_id').where('a.peer_did', '=', peerDID)))).orderBy('r.attempted_at').orderBy('r.document_id').limit(limit).execute();
             return rows.map((row)=>row.document_id);
         },
         async pruneDocumentRepairs (groupID, createdBefore) {
-            await db.deleteFrom('kubun_p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', 'in', (eb)=>eb.selectFrom('kubun_p2p_document_repairs').select('document_id').where('group_id', '=', groupID).where('created_at', '<', createdBefore)).execute();
-            await db.deleteFrom('kubun_p2p_document_repairs').where('group_id', '=', groupID).where('created_at', '<', createdBefore).execute();
+            await db.deleteFrom('p2p_document_repair_answers').where('group_id', '=', groupID).where('document_id', 'in', (eb)=>eb.selectFrom('p2p_document_repairs').select('document_id').where('group_id', '=', groupID).where('created_at', '<', createdBefore)).execute();
+            await db.deleteFrom('p2p_document_repairs').where('group_id', '=', groupID).where('created_at', '<', createdBefore).execute();
         },
         async getObservationRepairSchedules (documentIDs) {
             return await readSchedules(db, documentIDs);
         },
         async listDueObservationRepairSchedules (query) {
-            let select = db.selectFrom('kubun_p2p_observation_repairs as r').selectAll('r').where((eb)=>eb.or([
+            let select = db.selectFrom('p2p_observation_repairs as r').selectAll('r').where((eb)=>eb.or([
                     eb('r.next_attempt_at', '<=', query.now),
                     eb.and([
                         eb('r.tried_count', '<', query.maxTriedPeers),
-                        eb.not(eb.exists(eb.selectFrom('kubun_p2p_observation_repair_peers as p').select('p.peer_did').whereRef('p.document_id', '=', 'r.document_id').where('p.peer_did', '=', query.peerDID)))
+                        eb.not(eb.exists(eb.selectFrom('p2p_observation_repair_peers as p').select('p.peer_did').whereRef('p.document_id', '=', 'r.document_id').where('p.peer_did', '=', query.peerDID)))
                     ])
                 ]));
             const after = query.after;
@@ -212,15 +210,14 @@ export function createCatalogSyncOps(db, adapter) {
             return rows.map((row)=>scheduleFromRow(row, tried.get(row.document_id) ?? []));
         },
         async setObservationRepairSchedule (schedule) {
-            await inTransaction(async (tx)=>await writeSchedule(tx, schedule));
+            await withStoreTransaction(db, async (tx)=>await writeSchedule(tx, schedule));
         },
         async updateObservationRepairSchedule (documentID, update) {
-            return await inTransaction(async (tx)=>{
-                // Postgres runs sessions concurrently: serialize updates of one
-                // document. SQLite transactions already run one at a time.
-                if (adapter instanceof AbstractPostgresAdapter) {
-                    await sql`select pg_advisory_xact_lock(hashtextextended(${`kubun_p2p_observation_repairs:${documentID}`}, 0))`.execute(tx);
-                }
+            return await withP2PKeyLocks(context, 'p2p_observation_repairs', [
+                [
+                    documentID
+                ]
+            ], async (tx)=>{
                 const current = (await readSchedules(tx, [
                     documentID
                 ])).get(documentID);
@@ -231,17 +228,17 @@ export function createCatalogSyncOps(db, adapter) {
             });
         },
         async listObservationRepairScheduleIDs ({ after, limit }) {
-            let query = db.selectFrom('kubun_p2p_observation_repairs').select('document_id').orderBy('document_id').limit(limit);
+            let query = db.selectFrom('p2p_observation_repairs').select('document_id').orderBy('document_id').limit(limit);
             if (after !== null) query = query.where('document_id', '>', after);
             return (await query.execute()).map((row)=>row.document_id);
         },
         async deleteObservationRepairSchedules (documentIDs) {
             if (documentIDs.length === 0) return;
-            await inTransaction(async (tx)=>{
-                await tx.deleteFrom('kubun_p2p_observation_repair_peers').where('document_id', 'in', [
+            await withStoreTransaction(db, async (tx)=>{
+                await tx.deleteFrom('p2p_observation_repair_peers').where('document_id', 'in', [
                     ...documentIDs
                 ]).execute();
-                await tx.deleteFrom('kubun_p2p_observation_repairs').where('document_id', 'in', [
+                await tx.deleteFrom('p2p_observation_repairs').where('document_id', 'in', [
                     ...documentIDs
                 ]).execute();
             });