@ibgib/core-gib 0.1.25 → 0.1.26

package/src/sync/sync-saga-coordinator.mts

@@ -95,7 +95,7 @@ export class SyncSagaCoordinator {
      * @param opts.domainIbGibs - The root ibgibs defining the scope of the sync.
      * @param opts.useSessionIdentity - (Optional) Whether to create an ephemeral session identity. Default: true.
      */
-    async sync({
+    public async sync({
         peer,
         domainIbGibs,
         conflictStrategy = SyncConflictStrategy.abort,
@@ -191,6 +191,91 @@ export class SyncSagaCoordinator {
         };
     }
 
+    /**
+     * This is what the receiving side of the sync calls to drive the FSM to the
+     * next stage.
+     *
+     * So whereas the sender executes a saga loop and drives the entire process,
+     * this is a reactive one-off that drives just the single step that the
+     * receiver does in that saga.
+     *
+     * @returns next context result if another round, else if commit returns
+     * null
+     */
+    public async receiverContinueSync({
+        sagaContext,
+        mySpace,
+        myTempSpace,
+        identity,
+        identitySecret,
+        metaspace,
+    }: {
+        sagaContext: SyncSagaContextIbGib_V1,
+        /**
+         * Local space relative to the execution context's POV
+         */
+        mySpace: IbGibSpaceAny,
+        /**
+         * Local temp space relative to the execution context's POV
+         */
+        myTempSpace: IbGibSpaceAny,
+        identity?: KeystoneIbGib_V1,
+        identitySecret?: string,
+        metaspace: MetaspaceService,
+    }): Promise<SyncSagaContextIbGib_V1 | null> {
+        const lc = `${this.lc}[${this.receiverContinueSync.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: f64e08bf77d1425378601f380384ec26)`); }
+
+            const contextResult = await this.handleResponseSagaContext({
+                sagaContext,
+                mySpace,
+                myTempSpace,
+                identity,
+                identitySecret,
+                metaspace,
+            });
+
+            if (!contextResult) {
+                if (logalot) { console.log(`${lc} Handler returned null (Saga End). (I: 43da8bb6c846b1fe7766332643be0e26)`); }
+                return null;
+            }
+
+            // #region error conditions throw
+            if (contextResult.errorMsg) {
+                throw new Error(`Couldn't handle response saga context. errorMsg: ${contextResult.errorMsg} (E: 7b41a183cf3cb58a5859c803800cf826)`);
+            } else if (!contextResult.nextFrameInfo) {
+                throw new Error(`(UNEXPECTED) contextResult.nextFrameInfo falsy? (E: 5740542f5eb8ccb41dfec188d87c1e26)`);
+            } else if (contextResult.nextFrameInfo?.responseWasNull) {
+                throw new Error(`(UNEXPECTED) contextResult.nextFrameInfo.responseWasNull? logic flow should not have gotten here. (E: ae06748d8c0c5e70c92322c8fb0cb426)`);
+            }
+            // #endregion error conditions throw
+
+            // create the return context
+            const { frame, payloadIbGibsDomain } = contextResult.nextFrameInfo;
+
+            const responseCtx = await createSyncSagaContext({
+                sagaFrame: frame,
+                localSpace: mySpace,
+                payloadIbGibsDomain,
+                // todo: we need to thoroughly go through the identity per each step after getting basic merging
+                sessionKeystones: identity ? [identity] : undefined, // ??
+            });
+
+            const immediateValidationErrors = await validateContextAndSagaFrame({
+                context: responseCtx,
+            });
+            if (immediateValidationErrors.length > 0) { throw new Error(`(UNEXPECTED) just created sync saga context () and there were immediateValidationErrors? immediateValidationErrors: ${immediateValidationErrors} (E: c120e8e0aa98673d685267a8a36e5826)`); }
+
+            return responseCtx;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
     protected async getSessionIdentity({
         sagaId,
         metaspace,
@@ -253,6 +338,12 @@ export class SyncSagaCoordinator {
         metaspace
     }: {
         initFrame: SyncIbGib_V1,
+        /**
+         * This is the initial dependency graph of all domain ibgibs passed in
+         * to the original {@link sync} call.
+         *
+         * if we're executing on the sender, this will be populated
+         */
         initDomainGraph: FlatIbGibGraph,
         peer: SyncPeerWitness,
         sessionIdentity?: KeystoneIbGib_V1,
@@ -362,8 +453,11 @@ export class SyncSagaCoordinator {
             if (!responseCtx.data) { throw new Error(`(UNEXPECTED) responseCtx.data falsy? (E: a969992bae53ab18a827ec58aec15826)`); }
             updates$.next(responseCtx); // spins off for saga UI updating
 
-            // validate context
-            await validateContextAndSagaFrame
+            // immediately validate context/saga frame (but not payloads because
+            // we may not have those yet)
+            const contextAndSagaFrameValidationErrors =
+                await validateContextAndSagaFrame({ context: responseCtx });
+            if (contextAndSagaFrameValidationErrors.length > 0) { throw new Error(`contextAndSagaFrameValidationErrors: ${contextAndSagaFrameValidationErrors} (E: 6eebe8e7fa437c00a8cde3ada3c66826)`); }
 
             // Extract expected domain addresses from response context
             const responsePayloadAddrsDomain = responseCtx.data[SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN] as string[] || [];
@@ -399,6 +493,7 @@ export class SyncSagaCoordinator {
             // finished/errored out.
             const contextResult = await this.handleResponseSagaContext({
                 sagaContext: responseCtx,
+                initDomainGraph,
                 mySpace: localSpace,
                 myTempSpace: tempSpace,
                 metaspace,
@@ -708,6 +803,7 @@ export class SyncSagaCoordinator {
 
     /**
      * This is the heart of the "ping pong" transaction, where we send a context
+     *
      * and receive a context. IOW, this drives the FSM of the sync saga ibgib as
      * a whole.
      *
@@ -728,6 +824,7 @@ export class SyncSagaCoordinator {
      */
     public async handleResponseSagaContext({
         sagaContext,
+        initDomainGraph,
         mySpace,
         myTempSpace,
         identity,
@@ -735,6 +832,13 @@ export class SyncSagaCoordinator {
         metaspace,
     }: {
         sagaContext: SyncSagaContextIbGib_V1,
+        /**
+         * This is the initial dependency graph of all domain ibgibs passed in
+         * to the original {@link sync} call.
+         *
+         * if we're executing on the sender, this will be populated
+         */
+        initDomainGraph?: FlatIbGibGraph,
         /**
          * Local space relative to the execution context's POV
          */
@@ -746,7 +850,7 @@ export class SyncSagaCoordinator {
         identity?: KeystoneIbGib_V1,
         identitySecret?: string,
         metaspace: MetaspaceService,
-    }): Promise<HandleSagaResponseContextResult | null> {
+    }): Promise<HandleSagaResponseContextResult> {
         const lc = `${this.lc}[${this.handleResponseSagaContext.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting... (I: 5deec8a1f7a6d263c88cd458ad990826)`); }
@@ -780,7 +884,16 @@ export class SyncSagaCoordinator {
                     break;
 
                 case SyncStage.ack:
-                    nextFrameInfo = await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity });
+                    if (!initDomainGraph) { throw new Error(`(UNEXPECTED) initDomainGraph falsy on the sender? (E: a3d758ad954829aba88663188eafc826)`); }
+                    nextFrameInfo = await this.handleAckFrame({
+                        sagaIbGib,
+                        srcGraph,
+                        initDomainGraph,
+                        metaspace,
+                        destSpace: mySpace,
+                        tempSpace: myTempSpace,
+                        identity,
+                    });
                     break;
 
                 case SyncStage.delta:
@@ -1090,8 +1203,6 @@ export class SyncSagaCoordinator {
              * we want to push ibgibs to the remote/sender if we have push
              * offers. an ack frame's payloads, if any, are those push offers
              */
-            // let payloadIbGibsDomain: IbGib_V1[] | undefined = await getPushOffers
-
             let payloadIbGibsDomain: IbGib_V1[] | undefined;
             if (pushOfferInfos.length > 0) {
                 const searchSecondSpaceAddrs: IbGibAddr[] = [];
@@ -1143,12 +1254,10 @@ export class SyncSagaCoordinator {
                 // we have now populated payloadIbGibsDomain
             }
 
-            throw new Error(`not implemented (E: ed3f98abb0988c5ae8038bb8d741fb26)`);
-            // return {
-            //     frame: ackFrame,
-            //     // conflictInfos,
-            //     payloadIbGibsDomain,
-            // };
+            return {
+                frame: ackFrame,
+                payloadIbGibsDomain,
+            };
 
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
@@ -1173,6 +1282,7 @@ export class SyncSagaCoordinator {
     protected async handleAckFrame({
         sagaIbGib,
         srcGraph,
+        initDomainGraph,
         destSpace,
         tempSpace,
         metaspace,
@@ -1180,6 +1290,13 @@ export class SyncSagaCoordinator {
     }: {
         sagaIbGib: SyncIbGib_V1,
         srcGraph: { [addr: string]: IbGib_V1 },
+        /**
+         * This is the initial dependency graph of all domain ibgibs passed in
+         * to the original {@link sync} call.
+         *
+         * if we're executing on the sender, this will be populated
+         */
+        initDomainGraph: FlatIbGibGraph,
         destSpace: IbGibSpaceAny,
         tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
@@ -1215,11 +1332,12 @@ export class SyncSagaCoordinator {
                 throw new Error(`${lc} Peer reported terminal conflicts. (E: 23a0096ee05a2ccfa89334e8f156b426)`);
             }
 
-            const optimisticConflicts = conflicts.filter(c => !c.terminal);
+            // at this point, if we have conflicts, they are non-terminal
+
             const mergeDeltaReqs: string[] = []; // Additional requests for merging
 
-            if (optimisticConflicts.length > 0) {
-                console.log(`${lc} [CONFLICT DEBUG] Processing ${optimisticConflicts.length} optimistic conflicts`);
+            if (conflicts.length > 0) {
+                console.log(`${lc} [CONFLICT DEBUG] Processing ${conflicts.length} non-terminal conflicts`);
                 // We need to resolve these.
                 // Strategy:
                 // 1. Analyze Divergence (Sender vs Receiver)
@@ -1252,102 +1370,106 @@ export class SyncSagaCoordinator {
 
                 // Let's analyze and pull immediately.
 
-                for (const conflict of optimisticConflicts) {
-                    const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
-
-                    // Sender History
-                    // We need our own history for this timeline.
-                    // We know the 'senderTip' (remoteAddr in Ack).
-                    // Sender should verify it has this tip.
-
-                    // Compute Diffs
-                    // We need to find `receiverOnly` addrs.
-                    // Receiver sent us `timelineAddrs` (Full History).
-                    const receiverHistorySet = new Set(timelineAddrs);
-
-                    // We need our execution context's history for this senderTip.
-                    // We can fetch valid 'past' from space.
-                    const resSenderTip = await getFromSpace({ space: destSpace, addr: senderTip });
-                    const senderTipIbGib = resSenderTip.ibGibs?.[0];
-                    if (!senderTipIbGib) { throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 832f3804645878869ee3c13714366726)`); }
-
-                    // Basic Diff: Find what Receiver has that we don't.
-                    // Actually, we need to traverse OUR past to find commonality.
-                    const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
-
-                    const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
-
-                    if (receiverOnlyAddrs.length > 0) {
-                        console.log(`${lc} [CONFLICT DEBUG] Found ${receiverOnlyAddrs.length} receiver-only frames - need to pull for merge`);
-                        console.log(`${lc} [CONFLICT DEBUG] Receiver-only addrs:`, receiverOnlyAddrs);
-                        // PULL these frames from Peer into Local Space
-                        // (Validation: We trust peer for now / verification happens on put)
-                        for (const addr of receiverOnlyAddrs) {
-                            console.error(`${lc} [CONFLICT DEBUG] NOT IMPLEMENTED (E: e6bf1a9d2758c469bb2f97514062d826)`);
-                        }
-
-                        // Compute DELTA dependencies for each receiver-only frame
-                        // Find LCA to determine what dependencies we already have
-                        const lcaAddr = timelineAddrs.find(addr => senderHistory.includes(addr));
-                        console.log(`${lc} [CONFLICT DEBUG] LCA: ${lcaAddr || 'NONE'}`);
-
-                        const skipAddrsSet = new Set<string>();
-                        if (lcaAddr) {
-                            try {
-                                const lcaRes = await getFromSpace({ addr: lcaAddr, space: destSpace });
-                                const lcaIbGib = lcaRes.ibGibs?.[0];
-                                if (lcaIbGib) {
-                                    const lcaDeps = await getDependencyGraph({ ibGib: lcaIbGib, space: destSpace });
-                                    if (lcaDeps) Object.keys(lcaDeps).forEach(a => skipAddrsSet.add(a));
-                                    console.log(`${lc} [CONFLICT DEBUG] LCA deps to skip: ${skipAddrsSet.size}`);
-                                }
-                            } catch (e) {
-                                console.warn(`${lc} Error getting LCA deps: ${extractErrorMsg(e)}`);
-                            }
-                        }
-
-
-                        // For each receiver-only frame, get its DELTA dependency graph (minus LCA deps)
-                        for (const addr of receiverOnlyAddrs) {
-                            // Add the frame itself first
-                            if (!mergeDeltaReqs.includes(addr)) {
-                                mergeDeltaReqs.push(addr);
-                            }
-
-                            // Get the frame's delta dependencies (skip LCA's deps)
-                            try {
-                                const frameRes = await getFromSpace({ addr, space: destSpace });
-                                const frameIbGib = frameRes.ibGibs?.[0];
-
-                                if (frameIbGib) {
-                                    // Get dependency graph, skipping all LCA dependencies
-                                    const frameDeltaDeps = await getDependencyGraph({
-                                        ibGib: frameIbGib,
-                                        space: destSpace,
-                                        skipAddrs: Array.from(skipAddrsSet), // Skip entire LCA dep graph
-                                    });
-
-                                    if (frameDeltaDeps) {
-                                        // Add all delta dependencies (Object.keys gives us the addresses)
-                                        Object.keys(frameDeltaDeps).forEach(depAddr => {
-                                            if (!mergeDeltaReqs.includes(depAddr) && !skipAddrsSet.has(depAddr)) {
-                                                mergeDeltaReqs.push(depAddr);
-                                            }
-                                        });
-                                    }
-                                }
-                            } catch (depError) {
-                                console.warn(`${lc} [CONFLICT DEBUG] Error getting delta deps for ${addr}: ${extractErrorMsg(depError)}`);
-                            }
-                        }
-
-                        console.log(`${lc} [CONFLICT DEBUG] Total merge requests (frames + delta deps): ${mergeDeltaReqs.length}`);
-                    } else {
-                        console.log(`${lc} [CONFLICT DEBUG] No receiver-only frames found for this conflict`);
-                    }
+                for (const conflict of conflicts) {
+                    // todo: integrate conflict strategies into this point...this whole block needs to be redone, but I want to check the fast-forward/backward simpler case tests first
+
+                    throw new Error(`conflicts not (re)implemented yet (E: 3b7d0819f83842a6de3ae988819bc826)`);
+
+                    // const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
+
+                    // // Sender History
+                    // // We need our own history for this timeline.
+                    // // We know the 'senderTip' (remoteAddr in Ack).
+                    // // Sender should verify it has this tip.
+
+                    // // Compute Diffs
+                    // // We need to find `receiverOnly` addrs.
+                    // // Receiver sent us `timelineAddrs` (Full History).
+                    // const receiverHistorySet = new Set(timelineAddrs);
+
+                    // // We need our execution context's history for this senderTip.
+                    // // We can fetch valid 'past' from space.
+                    // const resSenderTip = await getFromSpace({ space: destSpace, addr: senderTip });
+                    // const senderTipIbGib = resSenderTip.ibGibs?.[0];
+                    // if (!senderTipIbGib) { throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 832f3804645878869ee3c13714366726)`); }
+
+                    // // Basic Diff: Find what Receiver has that we don't.
+                    // // Actually, we need to traverse OUR past to find commonality.
+                    // const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
+
+                    // const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
+
+                    // if (receiverOnlyAddrs.length > 0) {
+                    //     console.log(`${lc} [CONFLICT DEBUG] Found ${receiverOnlyAddrs.length} receiver-only frames - need to pull for merge`);
+                    //     console.log(`${lc} [CONFLICT DEBUG] Receiver-only addrs:`, receiverOnlyAddrs);
+                    //     // PULL these frames from Peer into Local Space
+                    //     // (Validation: We trust peer for now / verification happens on put)
+                    //     for (const addr of receiverOnlyAddrs) {
+                    //         console.error(`${lc} [CONFLICT DEBUG] NOT IMPLEMENTED (E: e6bf1a9d2758c469bb2f97514062d826)`);
+                    //     }
+
+                    //     // Compute DELTA dependencies for each receiver-only frame
+                    //     // Find LCA to determine what dependencies we already have
+                    //     const lcaAddr = timelineAddrs.find(addr => senderHistory.includes(addr));
+                    //     console.log(`${lc} [CONFLICT DEBUG] LCA: ${lcaAddr || 'NONE'}`);
+
+                    //     const skipAddrsSet = new Set<string>();
+                    //     if (lcaAddr) {
+                    //         try {
+                    //             const lcaRes = await getFromSpace({ addr: lcaAddr, space: destSpace });
+                    //             const lcaIbGib = lcaRes.ibGibs?.[0];
+                    //             if (lcaIbGib) {
+                    //                 const lcaDeps = await getDependencyGraph({ ibGib: lcaIbGib, space: destSpace });
+                    //                 if (lcaDeps) Object.keys(lcaDeps).forEach(a => skipAddrsSet.add(a));
+                    //                 console.log(`${lc} [CONFLICT DEBUG] LCA deps to skip: ${skipAddrsSet.size}`);
+                    //             }
+                    //         } catch (e) {
+                    //             console.warn(`${lc} Error getting LCA deps: ${extractErrorMsg(e)}`);
+                    //         }
+                    //     }
+
+
+                    //     // For each receiver-only frame, get its DELTA dependency graph (minus LCA deps)
+                    //     for (const addr of receiverOnlyAddrs) {
+                    //         // Add the frame itself first
+                    //         if (!mergeDeltaReqs.includes(addr)) {
+                    //             mergeDeltaReqs.push(addr);
+                    //         }
+
+                    //         // Get the frame's delta dependencies (skip LCA's deps)
+                    //         try {
+                    //             const frameRes = await getFromSpace({ addr, space: destSpace });
+                    //             const frameIbGib = frameRes.ibGibs?.[0];
+
+                    //             if (frameIbGib) {
+                    //                 // Get dependency graph, skipping all LCA dependencies
+                    //                 const frameDeltaDeps = await getDependencyGraph({
+                    //                     ibGib: frameIbGib,
+                    //                     space: destSpace,
+                    //                     skipAddrs: Array.from(skipAddrsSet), // Skip entire LCA dep graph
+                    //                 });
+
+                    //                 if (frameDeltaDeps) {
+                    //                     // Add all delta dependencies (Object.keys gives us the addresses)
+                    //                     Object.keys(frameDeltaDeps).forEach(depAddr => {
+                    //                         if (!mergeDeltaReqs.includes(depAddr) && !skipAddrsSet.has(depAddr)) {
+                    //                             mergeDeltaReqs.push(depAddr);
+                    //                         }
+                    //                     });
+                    //                 }
+                    //             }
+                    //         } catch (depError) {
+                    //             console.warn(`${lc} [CONFLICT DEBUG] Error getting delta deps for ${addr}: ${extractErrorMsg(depError)}`);
+                    //         }
+                    //     }
+
+                    //     console.log(`${lc} [CONFLICT DEBUG] Total merge requests (frames + delta deps): ${mergeDeltaReqs.length}`);
+                    // } else {
+                    //     console.log(`${lc} [CONFLICT DEBUG] No receiver-only frames found for this conflict`);
+                    // }
                 }
 
-                console.log(`${lc} [CONFLICT DEBUG] Finished processing ${optimisticConflicts.length} conflicts. mergeDeltaReqs: ${mergeDeltaReqs.length}`);
+                console.log(`${lc} [CONFLICT DEBUG] Finished processing ${conflicts.length} conflicts. mergeDeltaReqs: ${mergeDeltaReqs.length}`);
             } else {
                 console.log(`${lc} [CONFLICT DEBUG] No optimistic conflicts to process`);
             }

package/src/sync/sync-types.mts

@@ -57,8 +57,8 @@ export function isValidSyncConflictStrategy(strategy: string): strategy is SyncC
 export interface NextSagaFrameInfo_Frame {
     frame: SyncIbGib_V1;
     payloadIbGibsDomain?: IbGib_V1[];
-    conflictInfos?: SyncSagaConflictInfo;
-    responseWasNull: undefined;
+    // conflictInfos?: SyncSagaConflictInfo;
+    responseWasNull?: undefined;
 }
 export interface NextSagaFrameInfo_Null {
     frame: never;