@ibgib/core-gib 0.1.59 → 0.1.61

package/src/sync/sync-conflict-basic-divergence.withid.respec.mts

@@ -0,0 +1,321 @@
+/**
+ * @module sync-conflict-basic-divergence.withid.respec
+ *
+ * Verifies Basic Divergence Conflict Resolution (optimistic merge / grafting) with Identity.
+ */
+
+import {
+    respecfully, respecfullyDear, iReckon, ifWe
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+import { clone, delay } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../core-constants.mjs';
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { getFromSpace, putInSpace, registerNewIbGib } from '../witness/space/space-helper.mjs';
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { createTimelineRootTestHelper } from '../test-helpers.mjs';
+import { mut8Timeline } from '../timeline/timeline-api.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
+import { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mjs';
+import { SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1 } from './sync-peer/sync-peer-innerspace/sync-peer-innerspace-constants.mjs';
+import { getDependencyGraph, graphsAreEquivalent } from '../common/other/graph-helper.mjs';
+import { IbGib_V1, IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+
+import { KeystoneService_V1 } from '../keystone/keystone-service-v1.mjs';
+import {
+    KEYSTONE_VERB_SYNC, POOL_ID_SYNC,
+} from '../keystone/keystone-constants.mjs';
+import { createStandardPoolConfig } from '../keystone/keystone-config-builder.mjs';
+import { KeystoneReplenishStrategy } from '../keystone/keystone-types.mjs';
+import { SyncConflictStrategy } from './sync-constants.mjs';
+import { GRAFT_BASE_REL8N_NAME, GRAFT_ORPHAN_REL8N_NAME, GRAFT_INFO_REL8N_NAME } from './graft-info/graft-info-constants.mjs';
+import { getTjpAddr } from '../common/other/ibgib-helper.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT || true;
+const lc = `[sync-conflict-basic-divergence.withid.respec]`;
+
+const SENDER_SECRET = 'test-sender-secret-conflict-basic-divergence-withid';
+
+const SENDER_IDENTITY_SYNC_POOL_CONFIG = createStandardPoolConfig({
+    id: POOL_ID_SYNC,
+    salt: 'senderidentitysyncsaltconflictbasicdivergencewithid',
+    verbs: [KEYSTONE_VERB_SYNC],
+    size: 200,
+    sequential: 1,
+    random: 1,
+    targetBinding: 2,
+    replenishStrategy: KeystoneReplenishStrategy.topUp,
+});
+
+interface TestData extends IbGibData_V1 {
+    text?: string;
+    fieldA?: string;
+    fieldB?: string;
+}
+
+await respecfully(sir, `Sync Conflict Basic Divergence with Identity`, async () => {
+
+    for (let i = 0; i <= 1; i++) {
+        const srcMakesFirstDivergentEdit = i === 0;
+
+        await respecfully(sir, `srcMakesFirstDivergentEdit: ${srcMakesFirstDivergentEdit}`, async () => {
+            // 1. Setup Spaces
+            const metaspace = new Metaspace_Innerspace(undefined);
+            await metaspace.initialize({
+                getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+                getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+                getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${title}: ${msg}`); return null; },
+            });
+            while (!metaspace.initialized) { await delay(10); }
+
+            const defaultLocalUserSpace = await metaspace.getLocalUserSpace({ lock: false });
+            await defaultLocalUserSpace!.initialized;
+
+            const sourceSpace = new InnerSpace_V1({
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: 'source',
+                uuid: 'source_uuid',
+                description: 'source test space',
+            });
+            await sourceSpace.initialized;
+
+            const destSpace = new InnerSpace_V1({
+                ...DEFAULT_INNER_SPACE_DATA_V1,
+                name: 'dest',
+                uuid: 'dest_uuid',
+                description: 'dest test space',
+            });
+            await destSpace.initialized;
+
+            // 2. Setup Identities
+            const keystoneSvc = new KeystoneService_V1();
+            const r1_senderIdentity_v0_source = await keystoneSvc.genesis({
+                masterSecret: SENDER_SECRET,
+                configs: [SENDER_IDENTITY_SYNC_POOL_CONFIG],
+                metaspace,
+                space: sourceSpace,
+            });
+
+            // Register identity in both spaces
+            await metaspace.put({ ibGib: r1_senderIdentity_v0_source, space: destSpace });
+            await metaspace.registerNewIbGib({ ibGib: r1_senderIdentity_v0_source, space: destSpace });
+
+            // 3. Seed Common History (V0 -> V1)
+            const testRoot = await createTimelineRootTestHelper<TestData>({
+                ib: 'timeline_root_conflict_withid',
+                data: { type: 'testRoot', text: 'v0' },
+                space: sourceSpace,
+            });
+            const tjpAddr = getTjpAddr({ ibGib: testRoot, defaultIfNone: 'incomingAddr' }) ?? getIbGibAddr({ ibGib: testRoot });
+
+            // Create V1 (Common)
+            const v1_Common_onSource = await mut8Timeline<TestData>({
+                timeline: testRoot,
+                mut8Opts: {
+                    mut8Ib: testRoot.ib + '_common',
+                    dataToAddOrPatch: { text: 'v1_common' }
+                },
+                metaspace,
+                space: sourceSpace,
+            });
+
+            // Sync testRoot and V1 to Dest immediately
+            const depGraphCommon = await getDependencyGraph({
+                ibGibAddrs: [tjpAddr],
+                space: sourceSpace,
+                live: true,
+            }) ?? {};
+
+            await metaspace.put({ ibGibs: Object.values(depGraphCommon), space: destSpace });
+            await metaspace.registerNewIbGib({ ibGib: testRoot, space: destSpace });
+
+            const resGetDest = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: v1_Common_onSource }) });
+            if (!resGetDest.success || !resGetDest.ibGibs || resGetDest.ibGibs.length === 0) {
+                throw new Error("Failed to copy V1 to Dest");
+            }
+            const v1_Common_onDest = resGetDest.ibGibs[0];
+            await metaspace.registerNewIbGib({ ibGib: v1_Common_onDest, space: destSpace });
+
+            // 4. Create Divergence (V2a vs V2b)
+            let v2a: any;
+            let v2b: any;
+            let baseAddr: string;
+            let orphanAddr: string;
+
+            if (srcMakesFirstDivergentEdit) {
+                // Source: V1 -> V2a (Edit Field A)
+                v2a = await mut8Timeline<TestData>({
+                    timeline: v1_Common_onSource,
+                    mut8Opts: {
+                        mut8Ib: testRoot.ib + '_v2a',
+                        dataToAddOrPatch: { fieldA: 'source_edit' }
+                    },
+                    metaspace,
+                    space: sourceSpace,
+                });
+                baseAddr = getIbGibAddr({ ibGib: v2a });
+
+                await delay(16);
+
+                // Dest: V1 -> V2b (Edit Field B)
+                v2b = await mut8Timeline<TestData>({
+                    timeline: v1_Common_onDest,
+                    mut8Opts: {
+                        mut8Ib: testRoot.ib + '_v2b',
+                        dataToAddOrPatch: { fieldB: 'dest_edit' }
+                    },
+                    metaspace,
+                    space: destSpace,
+                });
+                orphanAddr = getIbGibAddr({ ibGib: v2b });
+            } else {
+                // Dest: V1 -> V2b (Edit Field B)
+                v2b = await mut8Timeline<TestData>({
+                    timeline: v1_Common_onDest,
+                    mut8Opts: {
+                        mut8Ib: testRoot.ib + '_v2b',
+                        dataToAddOrPatch: { fieldB: 'dest_edit' }
+                    },
+                    metaspace,
+                    space: destSpace,
+                });
+                baseAddr = getIbGibAddr({ ibGib: v2b });
+
+                await delay(16);
+
+                // Source: V1 -> V2a (Edit Field A)
+                v2a = await mut8Timeline<TestData>({
+                    timeline: v1_Common_onSource,
+                    mut8Opts: {
+                        mut8Ib: testRoot.ib + '_v2a',
+                        dataToAddOrPatch: { fieldA: 'source_edit' }
+                    },
+                    metaspace,
+                    space: sourceSpace,
+                });
+                orphanAddr = getIbGibAddr({ ibGib: v2a });
+            }
+
+            // 5. Setup Coordinators
+            const senderCoordinator = new SyncSagaCoordinator();
+            const receiverCoordinator = new SyncSagaCoordinator();
+
+            const peer = new SyncPeerInnerspace_V1(clone(SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1));
+            await peer.initialized;
+            await peer.initializeOpts({
+                localMetaspace: metaspace,
+                localSpace: sourceSpace,
+                receiverSpace: destSpace,
+                receiverCoordinator,
+                receiverMetaspace: metaspace,
+            });
+
+            // 6. Run Sync with Identity
+            console.log(`${lc} Running Sync...`);
+            const resSync = await senderCoordinator.sync({
+                peer,
+                localSpace: sourceSpace,
+                metaspace,
+                domainIbGibs: [v2a],
+                conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+                senderIdentity: r1_senderIdentity_v0_source,
+                fnSenderSecret: async () => SENDER_SECRET,
+            });
+            await resSync.done;
+
+            // #region r1 verify post
+            await respecfully(sir, `r1 verify post`, async () => {
+                await ifWe(sir, `verify graft/merge tip contains both edits and graft relations`, async () => {
+                    const sourceKV = await senderCoordinator.getKnowledgeMap({
+                        space: sourceSpace,
+                        metaspace,
+                        domainIbGibs: [testRoot]
+                    });
+                    const sourceTipAddr = sourceKV[tjpAddr];
+                    iReckon(sir, sourceTipAddr).asTo('Source tip exists').isGonnaBeTruthy();
+
+                    if (sourceTipAddr) {
+                        iReckon(sir, sourceTipAddr).asTo('Tip should not be v2a').not.isGonnaBe(getIbGibAddr({ ibGib: v2a }));
+                        iReckon(sir, sourceTipAddr).asTo('Tip should not be v2b').not.isGonnaBe(getIbGibAddr({ ibGib: v2b }));
+
+                        const resTip = await getFromSpace({ space: sourceSpace, addr: sourceTipAddr });
+                        const newTip = resTip.ibGibs![0] as IbGib_V1<TestData>;
+
+                        iReckon(sir, newTip.data!.fieldA).asTo('Merged fieldA').isGonnaBe('source_edit');
+                        iReckon(sir, newTip.data!.fieldB).asTo('Merged fieldB').isGonnaBe('dest_edit');
+
+                        const graftInfoRel = newTip.rel8ns?.[GRAFT_INFO_REL8N_NAME];
+                        iReckon(sir, graftInfoRel).asTo('New Tip has graftinfo rel8n').isGonnaBeTruthy();
+                        if (graftInfoRel?.[0]) {
+                            const resGraft = await getFromSpace({ space: sourceSpace, addr: graftInfoRel[0] });
+                            const graftInfo = resGraft.ibGibs![0];
+
+                            const baseRel = graftInfo.rel8ns?.[GRAFT_BASE_REL8N_NAME];
+                            const orphanRel = graftInfo.rel8ns?.[GRAFT_ORPHAN_REL8N_NAME];
+
+                            iReckon(sir, baseRel?.[0]).asTo('Base matches').isGonnaBe(baseAddr);
+                            iReckon(sir, orphanRel?.[0]).asTo('Orphan matches').isGonnaBe(orphanAddr);
+                        }
+                    }
+                });
+
+                await ifWe(sir, 'sessionIdentity evolved the expected number of times', async () => {
+                    const latestS = peer.currentSessionIdentity;
+                    iReckon(sir, latestS).asTo('latest session identity exists').isGonnaBeTruthy();
+                    if (latestS) {
+                        console.log("ACTUAL SESSION IDENTITY N:", latestS.data?.n);
+                        iReckon(sir, latestS.data?.n).asTo('session identity data.n').isGonnaBe(3); // conflict resolution adds one
+                    }
+                });
+
+                await ifWe(sir, 'sender durable space has I (evolved frame)', async () => {
+                    const latestSenderIdentityAddr = await metaspace.getLatestAddr({
+                        addr: getIbGibAddr({ ibGib: r1_senderIdentity_v0_source }),
+                        space: sourceSpace,
+                    });
+                    iReckon(sir, latestSenderIdentityAddr).asTo('latestSenderIdentityAddr exists').isGonnaBeTruthy();
+                    if (latestSenderIdentityAddr) {
+                        const resGetSourceI = await getFromSpace({ space: sourceSpace, addr: latestSenderIdentityAddr });
+                        iReckon(sir, resGetSourceI.success && resGetSourceI.ibGibs?.length === 1).asTo('evolved I exists in sourceSpace').isGonnaBeTrue();
+                        if (resGetSourceI.success && resGetSourceI.ibGibs?.[0]) {
+                            const evolvedI = resGetSourceI.ibGibs[0];
+                            iReckon(sir, evolvedI.data?.n).asTo('evolved I data.n').isGonnaBe(1);
+                        }
+                    }
+                });
+
+                await ifWe(sir, 'receiver durable space has I (evolved frame)', async () => {
+                    const latestSenderIdentityAddr = await metaspace.getLatestAddr({
+                        addr: getIbGibAddr({ ibGib: r1_senderIdentity_v0_source }),
+                        space: sourceSpace,
+                    });
+                    iReckon(sir, latestSenderIdentityAddr).asTo('latestSenderIdentityAddr exists').isGonnaBeTruthy();
+                    if (latestSenderIdentityAddr) {
+                        const resGetDestI = await getFromSpace({ space: destSpace, addr: latestSenderIdentityAddr });
+                        iReckon(sir, resGetDestI.success && resGetDestI.ibGibs?.length === 1).asTo('evolved I exists in destSpace').isGonnaBeTrue();
+                        if (resGetDestI.success && resGetDestI.ibGibs?.[0]) {
+                            const evolvedI = resGetDestI.ibGibs[0];
+                            iReckon(sir, evolvedI.data?.n).asTo('evolved I data.n').isGonnaBe(1);
+                        }
+                    }
+                });
+
+                await ifWe(sir, 'session keystone dependency graphs are equivalent on source and dest', async () => {
+                    const latestS = peer.currentSessionIdentity;
+                    iReckon(sir, latestS).asTo('latestS exists').isGonnaBeTruthy();
+                    if (latestS) {
+                        const depGraphSource = await getDependencyGraph({ ibGib: latestS, space: sourceSpace });
+                        const depGraphDest = await getDependencyGraph({ ibGib: latestS, space: destSpace });
+                        const equal = graphsAreEquivalent({ graphA: depGraphSource, graphB: depGraphDest });
+                        iReckon(sir, equal).asTo('session graphs are equivalent').isGonnaBeTrue();
+                    }
+                });
+            });
+            // #endregion r1 verify post
+        });
+    }
+
+});