@ibgib/core-gib 0.1.8 → 0.1.10

package/src/sync/sync-helpers.mts

@@ -0,0 +1,59 @@
+import { extractErrorMsg } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { Ib } from "@ibgib/ts-gib/dist/types.mjs";
+import { SYNC_ATOM } from "./sync-constants.mjs";
+import { SyncData_V1, SyncIbInfo_V1 } from "./sync-types.mjs";
+
+const GLOBAL_LOG_A_LOT = false; // Todo: import from core constants if needed
+const logalot = GLOBAL_LOG_A_LOT;
+
+/**
+ * Constructs the standard 'ib' string for a Sync frame.
+ */
+export async function getSyncIb({
+    data,
+}: {
+    data: SyncData_V1,
+}): Promise<Ib> {
+    const lc = `[${getSyncIb.name}]`;
+    try {
+        // sync uuid stage
+        // e.g. "sync 1234-5678 init"
+        const ib = [
+            SYNC_ATOM,
+            data.uuid,
+            data.stage
+        ].join(' ');
+
+        return ib;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}
+
+/**
+ * Parses a standard Sync 'ib' string.
+ */
+export async function parseSyncIb({
+    ib,
+}: {
+    ib: Ib,
+}): Promise<SyncIbInfo_V1> {
+    const lc = `[${parseSyncIb.name}]`;
+    try {
+        const parts = ib.split(' ');
+        if (parts.length !== 3) {
+            throw new Error(`Invalid sync ib. Expected 3 parts [atom uuid stage]. Got ${parts.length}. (E: 7c8d9...)`);
+        }
+        const [atom, uuid, stage] = parts;
+
+        if (atom !== SYNC_ATOM) {
+            throw new Error(`Invalid sync ib. Expected atom '${SYNC_ATOM}', got '${atom}'. (E: 8f9e1...)`);
+        }
+
+        return { atom, uuid, stage: stage as any };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}

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.`);
+
+    });
+});