@ibgib/core-gib 0.1.9 → 0.1.11

package/src/sync/sync-innerspace.respec.mts

@@ -0,0 +1,144 @@
+/**
+ * @module sync-innerspace.respec
+ * 
+ * Verifies SyncSagaCoordinator using InnerSpace (in-memory/local) spaces.
+ * This avoids disk I/O issues and focuses on the synchronization logic.
+ */
+
+import {
+    respecfully, lastOfAll, ifWe, iReckon,
+    ifWeMight
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { putInSpace, getFromSpace } 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 { createStoneHelper, createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
+import { mut8Timeline, appendToTimeline } from '../timeline/timeline-api.mjs';
+
+const logalot = true;
+const lc = `[sync-innerspace.respec]`;
+
+await respecfully(sir, `Sync InnerSpaces`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+    let sourceSpace: InnerSpace_V1;
+    let destSpace: InnerSpace_V1;
+
+    // Setup before each test? Or once? 
+    // For now, let's just do it inside the test block to be safe/simple.
+
+    await ifWe(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+        // await ifWeMight(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+        // 1. Setup Spaces
+        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; },
+        });
+
+        // Create two distinct inner spaces manually or via metaspace if supported
+        // Metaspace_Innerspace typically manages one local user space, but we can instantiate InnerSpace_V1 directly.
+        sourceSpace = new InnerSpace_V1({ name: 'source', uuid: 'source_uuid' } as any);
+        await (sourceSpace as any).initialize();
+
+        destSpace = new InnerSpace_V1({ name: 'dest', uuid: 'dest_uuid' } as any);
+        await (destSpace as any).initialize();
+
+        // 2. Seed Source Data
+
+        // 2.1 Create a "Stone"
+        console.log(`${lc} Creating Stone...`);
+        const stone = await createStoneHelper({
+            ib: 'stone_data',
+            data: { some: 'data' },
+        });
+        const stoneAddr = getIbGibAddr({ ibGib: stone });
+        await putInSpace({ space: sourceSpace, ibGibs: [stone] });
+
+        // 2.2 Create a "Living" Timeline (Root)
+        console.log(`${lc} Creating Timeline Root...`);
+        const root = await createTimelineRootHelper({
+            ib: 'timeline_root',
+            data: { type: 'root', n: 0 },
+            space: sourceSpace,
+        });
+        const rootAddr = getIbGibAddr({ ibGib: root });
+
+        // 2.3 Evolve Timeline (Root -> Child)
+        // using mut8Timeline to simulate evolution
+        console.log(`${lc} Evolving Timeline...`);
+        const child = await mut8Timeline({
+            timeline: root,
+            mut8Opts: {
+                dataToAddOrPatch: { type: 'child', n: 1 }
+            },
+            metaspace,
+            space: sourceSpace,
+            // We use skipLock=true for simplicity in single-threaded test setup if locking is complex,
+            // but timeline-api handles locking. Let's try default first.
+            // Actually InnerSpace locking might be no-op or simple.
+        });
+        const childAddr = getIbGibAddr({ ibGib: child });
+
+        // 2.4 Rel8 Child to Stone (Dependency)
+        console.log(`${lc} Linking Child to Stone...`);
+        const childWithRel = await appendToTimeline({
+            timeline: child,
+            rel8nInfos: [{
+                rel8nName: 'linked_stone',
+                ibGibs: [stone]
+            }],
+            metaspace,
+            space: sourceSpace,
+        });
+        const childWithRelAddr = getIbGibAddr({ ibGib: childWithRel });
+
+        // 3. Setup Sync Coordinator
+        console.log(`${lc} Setting up Coordinator...`);
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const identity = await (mockKeystone as any).getIdentity();
+        const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+        // 4. Run Sync
+        console.log(`${lc} Running Sync...`);
+        const syncRes = await coordinator.sync({
+            source: sourceSpace,
+            dest: destSpace,
+            domainIbGibs: [childWithRel], // Sync starting from the tip
+            identity
+        });
+
+        // 5. Verify Dest
+        console.log(`${lc} Verifying Destination...`);
+
+        // Check Stone
+        const getStone = await getFromSpace({ space: destSpace, addr: stoneAddr });
+        iReckon(sir, getStone.success).asTo('getStone.success').isGonnaBeTrue();
+        iReckon(sir, getStone.ibGibs?.[0]).asTo('stone in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Stone synced.`);
+
+        // Check Root (Dependency of Child)
+        const getRoot = await getFromSpace({ space: destSpace, addr: rootAddr });
+        iReckon(sir, getRoot.success).asTo('getRoot.success').isGonnaBeTrue();
+        iReckon(sir, getRoot.ibGibs?.[0]).asTo('root in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Root synced.`);
+
+        // Check Child (Dependency of ChildWithRel)
+        const getChild = await getFromSpace({ space: destSpace, addr: childAddr });
+        iReckon(sir, getChild.success).asTo('getChild.success').isGonnaBeTrue();
+        iReckon(sir, getChild.ibGibs?.[0]).asTo('child in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Child synced.`);
+
+        // Check ChildWithRel (The Tip)
+        const getChildWithRel = await getFromSpace({ space: destSpace, addr: childWithRelAddr });
+        iReckon(sir, getChildWithRel.success).asTo('getChildWithRel.success').isGonnaBeTrue();
+        iReckon(sir, getChildWithRel.ibGibs?.[0]).asTo('childWithRel in dest').isGonnaBeTruthy();
+        console.log(`${lc} Verified Timeline Tip synced.`);
+
+    });
+});

package/src/sync/sync-local-spaces.respec.mts

@@ -0,0 +1,200 @@
+import { rm } from 'node:fs/promises';
+import { default as pathUtils } from 'path';
+
+import {
+    respecfully, lastOfAll
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { rel8 } from '@ibgib/ts-gib/dist/V1/transforms/rel8.mjs';
+import { getIbGibAddr, } from '@ibgib/ts-gib/dist/helper.mjs';
+import { IBGIB_ENCODING } from '../witness/space/filesystem-space/filesystem-constants.mjs';
+import { NodeFilesystemSpace_V1 } from '../witness/space/filesystem-space/node-filesystem-space/node-filesystem-space-v1.mjs';
+import { NodeFilesystemSpaceData_V1 } from '../witness/space/filesystem-space/node-filesystem-space/node-filesystem-space-types.mjs';
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { SyncStage } from './sync-constants.mjs';
+import { getTimestampInTicks, getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { GIB, IBGIB_DELIMITER } from '@ibgib/ts-gib/dist/V1/constants.mjs';
+import { putInSpace, getFromSpace } from '../witness/space/space-helper.mjs';
+import { KeystoneService_V1 } from '../keystone/keystone-service-v1.mjs';
+import { KeystoneIbGib_V1 } from '../keystone/keystone-types.mjs';
+import { mut8 } from '@ibgib/ts-gib/dist/V1/transforms/mut8.mjs';
+
+const logalot = true;
+const lc = `[sync-local-spaces.respec]`;
+
+// Helper to create a temp space
+const createTempSpace = async ({
+    baseDir,
+    name
+}: {
+    baseDir: string,
+    name: string
+}): Promise<NodeFilesystemSpace_V1> => {
+    const uuid = await getUUID();
+    const initialData: NodeFilesystemSpaceData_V1 = {
+        version: '1',
+        classname: NodeFilesystemSpace_V1.name,
+        uuid,
+        name,
+        description: `Temp space for ${name}`,
+        baseDir,
+        baseSubPath: 'ibgib', // keep short to avoid long path issues
+        spaceSubPath: name,
+        ibgibsSubPath: 'ibgibs',
+        metaSubPath: 'meta',
+        binSubPath: 'bin',
+        dnaSubPath: 'dna',
+        encoding: IBGIB_ENCODING,
+        mitigateLongPaths: true,
+        // other defaults
+        catchAllErrors: false,
+        trace: false,
+    };
+
+    // mimic constructor logic if needed, or just new it up
+    const space = new NodeFilesystemSpace_V1(initialData);
+    // Explicitly initialize if needed (based on findings, constructor calls super which calls initialize? 
+    // Actually source had it commented out in ctor. Let's call it via a witness "put" which should verify initialization)
+    return space;
+};
+
+// class MockKeystoneService implements KeystoneService_V1 {
+//     async getIdentity(): Promise<KeystoneIbGib_V1> {
+//         // Return a dummy identity
+//         const res = await Factory_V1.firstGen({
+//             ib: 'identity',
+//             data: { uuid: await getUUID() },
+//             dna: true,
+//         });
+//         return res.newIbGib as KeystoneIbGib_V1;
+//     }
+//     // Implement other methods as no-ops or simple mocks
+//     async sign(ibGib: any): Promise<any> { return ibGib; }
+//     async verify(ibGib: any): Promise<boolean> { return true; }
+//     // Add other required properties/methods of KeystoneService_V1 if any (checking interface might be needed)
+//     // Assuming for now these are the core ones used by Coordinator.
+//     // If strict interface, might need more.
+// }
+
+await respecfully(sir, `Sync Local Spaces`, async () => {
+
+    const TEST_ROOT = pathUtils.join(process.cwd(), 'tmp_sync_test_' + await getUUID());
+
+    lastOfAll(sir, async () => {
+        if (!logalot) {
+            await rm(TEST_ROOT, { recursive: true, force: true });
+        } else {
+            console.log(`${lc} Leaving TEST_ROOT for inspection: ${TEST_ROOT}`);
+        }
+    });
+
+    await respecfully(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+        // // 1. Setup Spaces
+        // const srcDir = pathUtils.join(TEST_ROOT, 'source');
+        // const destDir = pathUtils.join(TEST_ROOT, 'dest');
+
+        // const sourceSpace = await createTempSpace({ baseDir: srcDir, name: 'source' });
+        // const destSpace = await createTempSpace({ baseDir: destDir, name: 'dest' });
+
+        // // 2. Seed Source Data
+        // // 2.1 Create a "Stone" (Primitive-like or just immutable data)
+        // const stoneRes = await Factory_V1.firstGen({
+        //     ib: 'stone_data',
+        //     data: { some: 'data', timestamp: getTimestampInTicks() },
+        //     dna: false,
+        // });
+        // const stone = stoneRes.newIbGib;
+        // const stoneAddr = getIbGibAddr({ ibGib: stone });
+
+        // // 2.2 Create a "Living" Timeline (Root -> Child)
+        // const rootRes = await Factory_V1.firstGen({
+        //     ib: 'timeline_root',
+        //     data: { type: 'root' },
+        //     dna: true,
+        // });
+        // const root = rootRes.newIbGib;
+        // const rootAddr = getIbGibAddr({ ibGib: root });
+
+        // const childRes = await mut8({
+        //     type: 'fork',
+        //     src: root,
+        //     dna: true,
+        //     data: { type: 'child', n: 1 }
+        // });
+        // const child = childRes.newIbGib;
+        // const childAddr = getIbGibAddr({ ibGib: child });
+
+        // // Put into Source
+        // await putInSpace({
+        //     space: sourceSpace,
+        //     ibGibs: [stone, root, child]
+        // });
+
+        // // 3. Setup Sync Coordinator
+        // const mockKeystone = new MockKeystoneService() as unknown as KeystoneService_V1;
+        // const identity = await mockKeystone.getIdentity();
+        // const coordinator = new SyncSagaCoordinator(mockKeystone);
+
+        // // Define domain (roots to sync)
+        // const domainIbGibs = [root]; // We only explicitly track the "Living" root. Stone is standalone? 
+        // // Actually for the test let's explicitly include both or rely on dependency graph.
+        // // If 'stone' is not related to 'root', it won't be picked up unless we add it to domain.
+        // // Let's Rel8 the stone to the child to test dependency traversal.
+
+        // const childWithRelRes = await rel8({
+        //     src: child,
+        //     rel8nsToAddByAddr: { 'linked_stone': [stoneAddr] },
+        //     dna: true,
+        // });
+        // const childWithRel = childWithRelRes.newIbGib;
+        // const childWithRelAddr = getIbGibAddr({ ibGib: childWithRel });
+
+        // // Update Source with linked child
+        // await putInSpace({
+        //     space: sourceSpace,
+        //     ibGibs: [childWithRel]
+        // });
+
+        // // 4. Run Sync
+        // const syncRes = await coordinator.sync({
+        //     source: sourceSpace,
+        //     dest: destSpace,
+        //     domainIbGibs: [childWithRel], // Sync starting from the tip
+        //     identity
+        // });
+
+        // // 5. Verify Dest
+        // // Check Stone
+        // const getStone = await getFromSpace({
+        //     space: destSpace,
+        //     addr: stoneAddr
+        // });
+        // if (!getStone.success || !getStone.ibGibs?.[0]) {
+        //     throw new Error(`Dest failed to get Stone: ${stoneAddr}`);
+        // }
+        // console.log(`${lc} Verified Stone synced.`);
+
+        // // Check ChildWithRel (Tip)
+        // const getChild = await getFromSpace({
+        //     space: destSpace,
+        //     addr: childWithRelAddr
+        // });
+        // if (!getChild.success || !getChild.ibGibs?.[0]) {
+        //     throw new Error(`Dest failed to get ChildWithRel: ${childWithRelAddr}`);
+        // }
+        // console.log(`${lc} Verified Timeline Tip synced.`);
+
+        // // Check Root (Dependency)
+        // const getRoot = await getFromSpace({
+        //     space: destSpace,
+        //     addr: rootAddr
+        // });
+        // if (!getRoot.success || !getRoot.ibGibs?.[0]) {
+        //     throw new Error(`Dest failed to get Root: ${rootAddr}`);
+        // }
+        // console.log(`${lc} Verified Root synced.`);
+
+    });
+});