@ibgib/core-gib 0.1.9 → 0.1.11

package/src/test/mock-space.mts

@@ -0,0 +1,85 @@
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+
+/**
+ * A simple in-memory map acting as a Space.
+ * Pure Storage. No Indexing logic.
+ * 
+ * Copied/Adapted from Keystone Respecs.
+ */
+export class MockIbGibSpace {
+    store = new Map<string, IbGib_V1>();
+
+    constructor(public name: string = "mock_space") { }
+
+    async put({ ibGib }: { ibGib: IbGib_V1 }): Promise<void> {
+        const addr = getIbGibAddr({ ibGib });
+        this.store.set(addr, JSON.parse(JSON.stringify(ibGib))); // Deep copy
+    }
+
+    async get({ addr }: { addr: string }): Promise<IbGib_V1 | null> {
+        const data = this.store.get(addr);
+        return data ? JSON.parse(JSON.stringify(data)) : null;
+    }
+
+    async witness(arg: any): Promise<any> {
+        const cmd = arg.data?.cmd;
+        if (cmd === 'get') {
+            const addrs = arg.data.ibGibAddrs || [];
+            const ibGibs: IbGib_V1[] = [];
+            for (const addr of addrs) {
+                const ig = await this.get({ addr });
+                if (ig) ibGibs.push(ig);
+            }
+            return { ibGibs };
+        }
+        if (cmd === 'put') {
+            const ibGibs = arg.ibGibs || [];
+            for (const ibGib of ibGibs) {
+                await this.put({ ibGib });
+            }
+            return { ibGibs: [] }; // Return empty result or whatever witness expects
+        }
+        return undefined;
+    }
+}
+
+/**
+ * A partial mock of Metaspace.
+ */
+export class MockMetaspaceService {
+
+    /**
+     * Map of TJP Gib (Timeline ID) -> Latest IbGib Addr (Head)
+     */
+    timelineHeads = new Map<string, string>();
+
+    constructor(public space: MockIbGibSpace) { }
+
+    async getLocalUserSpace({ lock }: { lock: boolean }): Promise<MockIbGibSpace> {
+        return this.space;
+    }
+
+    async put(args: any): Promise<void> {
+        const target = args.space || this.space;
+        return target.put(args);
+    }
+
+    async registerNewIbGib(args: { ibGib: IbGib_V1, space?: any }): Promise<void> {
+        const { ibGib } = args;
+        const targetSpace = args.space || this.space;
+
+        // 1. Ensure it is stored
+        await targetSpace.put({ ibGib });
+
+        // 2. Extract TJP
+        const gib = ibGib.gib || '';
+        let tjpGib = gib;
+        if (gib.includes('.')) {
+            const parts = gib.split('.');
+            tjpGib = parts.slice(1).join('.');
+        }
+        const addr = getIbGibAddr({ ibGib });
+        this.timelineHeads.set(tjpGib, addr);
+    }
+}

package/src/timeline/timeline-api.respec.mts

@@ -0,0 +1,237 @@
+/**
+ * @module timeline-api.respec
+ *
+ * specs for the high-level timeline api.
+ */
+
+import {
+    firstOfEach, firstOfAll, ifWe,
+    lastOfEach, lastOfAll,
+    ifWeMight, iReckon, respecfully, respecfullyDear
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+import { IbGib_V1, IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
+import {
+    getLatestAddrs, persistTransformResult, registerNewIbGib, getFromSpace
+} from '../witness/space/space-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import {
+    createTimeline, mut8Timeline, appendToTimeline, getHistory
+} from './timeline-api.mjs';
+import { MetaspaceService } from '../witness/space/metaspace/metaspace-types.mjs';
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+import { IbGibSpaceAny } from '../witness/space/space-base-v1.mjs';
+
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+
+const maam = `[${import.meta.url}]`, sir = maam;
+
+interface TestData extends IbGibData_V1 {
+    note?: string;
+    testId?: string;
+    uniq?: number;
+}
+
+respecfully(sir, `[timeline-api]`, async () => {
+
+    let space: InnerSpace_V1;
+    let metaspace: Metaspace_Innerspace;
+
+    firstOfEach(sir, async () => {
+        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; },
+        });
+        space = metaspace.zeroSpace as InnerSpace_V1;
+    });
+
+    await ifWe(sir, `createTimeline`, async () => {
+        const res = await createTimeline<TestData>({
+            space,
+            metaspace,
+            data: { note: 'first timeline' },
+            ib: 'timeline',
+        });
+
+        const newTimeline = res.newIbGib;
+        iReckon(sir, newTimeline).asTo('newTimeline').isGonnaBeTruthy();
+        const addr = getIbGibAddr({ ibGib: newTimeline });
+
+        // verify persistence
+        const resGet = await getFromSpace({ addr, space });
+        iReckon(sir, resGet.success).asTo('persisted success').isGonnaBeTrue();
+        iReckon(sir, resGet.ibGibs![0]).asTo('persisted ibGib').isGonnaBe(newTimeline);
+    });
+
+    await ifWe(sir, `mut8Timeline`, async () => {
+        // Arrange
+        const resCreate = await createTimeline<TestData>({
+            space,
+            metaspace,
+            data: { note: 'orig' },
+            ib: 'timeline',
+        });
+        const timeline = resCreate.newIbGib;
+        console.log(`[mut8Timeline] created timeline n=${timeline.data!.n}`);
+        const initialPastLength = timeline.rel8ns?.past?.length || 0;
+        console.log(`[mut8Timeline] created timeline past length=${initialPastLength}`);
+
+        // Act
+        const mutatedTimeline = await mut8Timeline<TestData>({
+            timeline,
+            metaspace,
+            space,
+            mut8Opts: {
+                dataToAddOrPatch: { note: 'mutated' },
+            }
+        });
+        console.log(`[mut8Timeline] mutated timeline n=${mutatedTimeline.data!.n}`);
+
+
+        // Assert
+        iReckon(sir, mutatedTimeline).asTo('mutatedTimeline').isGonnaBeTruthy();
+        iReckon(sir, mutatedTimeline.data!.note).asTo('data.note').isGonnaBe('mutated');
+
+        // n should increment by 1
+        const expectedN = (timeline.data!.n || 0) + 1;
+        iReckon(sir, mutatedTimeline.data!.n).asTo('data.n').isGonnaBe(expectedN);
+
+        iReckon(sir, mutatedTimeline.rel8ns!.past).asTo('past').isGonnaBeTruthy();
+        // past length should include the previous frame + whatever it had
+        iReckon(sir, mutatedTimeline.rel8ns!.past!.length).asTo('past length').isGonnaBe(initialPastLength + 1);
+        iReckon(sir, mutatedTimeline.rel8ns!.past!.at(-1)).asTo('past addr').isGonnaBe(getIbGibAddr({ ibGib: timeline }));
+    });
+
+    await ifWe(sir, `appendToTimeline`, async () => {
+        // Arrange
+        const resCreate = await createTimeline<TestData>({
+            space,
+            metaspace,
+            data: { n: 0 },
+            ib: 'timeline',
+        });
+        let timeline = resCreate.newIbGib;
+        const rel8nInfos = [{
+            rel8nName: 'attachment',
+            ibGibs: [timeline] // just attaching itself as a test, weird but valid structure
+        }];
+        const timelinePastLength = timeline.rel8ns?.past?.length || 0;
+
+        // Act
+        const appendedTimeline = await appendToTimeline({
+            timeline,
+            rel8nInfos,
+            metaspace,
+            space,
+        });
+
+        // Assert
+        iReckon(sir, appendedTimeline).asTo('appendedTimeline').isGonnaBeTruthy();
+        iReckon(sir, appendedTimeline.rel8ns!.attachment).asTo('attachment').isGonnaBeTruthy();
+        iReckon(sir, appendedTimeline.rel8ns!.past?.length).asTo('past').isGonnaBe(timelinePastLength + 1);
+    });
+
+    await ifWe(sir, `getHistory`, async () => {
+        // Arrange
+        let t0 = (await createTimeline<TestData>({ space, metaspace, data: { n: 0 }, ib: 'timeline' })).newIbGib;
+        let t1 = await mut8Timeline<TestData>({ timeline: t0, metaspace, space, mut8Opts: { dataToAddOrPatch: { n: 1 } } });
+        let t2 = await mut8Timeline<TestData>({ timeline: t1, metaspace, space, mut8Opts: { dataToAddOrPatch: { n: 2 } } });
+
+        // Act
+        const history = await getHistory({
+            timeline: t2,
+            metaspace,
+            space,
+        });
+
+        // Assert
+        // t0 is actually 2nd frame (fork -> mut8).
+        // so history is [genesis, t0, t1]. length 3.
+        iReckon(sir, history.orderedPastIbGibs.length).asTo('history length').isGonnaBe(3);
+        // index 0 is genesis (the fork)
+        // index 1 is t0
+        // index 2 is t1
+        iReckon(sir, getIbGibAddr({ ibGib: history.orderedPastIbGibs[1] })).asTo('t0').isGonnaBe(getIbGibAddr({ ibGib: t0 }));
+        iReckon(sir, getIbGibAddr({ ibGib: history.orderedPastIbGibs[2] })).asTo('t1').isGonnaBe(getIbGibAddr({ ibGib: t1 }));
+        iReckon(sir, getIbGibAddr({ ibGib: history.headIbGib })).asTo('head').isGonnaBe(getIbGibAddr({ ibGib: t2 }));
+    });
+
+    await ifWe(sir, `Concurrency & Locking (Stress Test)`, async () => {
+        // const concurrencyLevels = [1, 2, 5, 50, 1000]; // too slow, because the locking mechanism doesn't scale well.
+        const concurrencyLevels = [1, 2, 5, 50];
+
+        for (const N of concurrencyLevels) {
+            console.log(`[Stress Test] Testing concurrency level: ${N}`);
+
+            // Arrange: Baseline
+            let tInitial = (await createTimeline<TestData>({
+                space,
+                metaspace,
+                data: { n: 0, testId: `concurrent-${N}` },
+                ib: 'timeline',
+            })).newIbGib;
+
+            // Initial state check
+            const initialN = (tInitial.data!.n || 0); // should be 1
+            const historyInitial = await getHistory({ timeline: tInitial, metaspace, space });
+            const initialHistoryLength = historyInitial.orderedPastIbGibs.length; // should be 1 (genesis)
+
+            // Act: Launch N mutations simultaneously
+            const promises: Promise<any>[] = [];
+            for (let i = 0; i < N; i++) {
+                promises.push(mut8Timeline<TestData>({
+                    timeline: tInitial, // All start referencing the same initial frame (or logically the timeline itself)
+                    // Note: In reality, if we pass the *same* object tInitial, mut8Timeline should
+                    // resolve the *latest* inside the function.
+                    metaspace,
+                    space,
+                    mut8Opts: {
+                        dataToAddOrPatch: {
+                            uniq: i, // distinct data to ensure unique hashes if needed
+                        }
+                    }
+                    // No skipLock! We want them to contend.
+                }));
+            }
+
+            try {
+                // Wait for all to complete
+                await Promise.all(promises);
+
+                // Verification
+                // 1. Get Latest Address
+                const resLatest = await getLatestAddrs({ ibGibs: [tInitial], space });
+                const latestAddr = resLatest.data!.latestAddrsMap![getIbGibAddr({ ibGib: tInitial })] as string;
+
+                iReckon(sir, latestAddr).asTo(`[N=${N}] latestAddr exists`).isGonnaBeTruthy();
+
+                // 2. Load the latest frame
+                const resGet = await getFromSpace({ addr: latestAddr, space });
+                const latestIbGib = resGet.ibGibs![0];
+
+                // 3. Verify data.n
+                // Initial n=1. We did N mutations.
+                // Each mutation increments nCounter.
+                const expectedN = initialN + N;
+                iReckon(sir, latestIbGib.data!.n).asTo(`[N=${N}] data.n should be ${expectedN}`).isGonnaBe(expectedN);
+
+                // 4. Verify Lineage (no divergence)
+                // History length should be initialHistoryLength + N
+                const history = await getHistory({ timeline: latestIbGib, metaspace, space });
+                const expectedHistoryLength = initialHistoryLength + N;
+                iReckon(sir, history.orderedPastIbGibs.length).asTo(`[N=${N}] history length`).isGonnaBe(expectedHistoryLength);
+
+                console.log(`[Stress Test] [N=${N}] SUCCESS. Final n=${latestIbGib.data!.n}`);
+
+            } catch (err) {
+                console.error(`[Stress Test] [N=${N}] FAILED:`, err);
+                throw err;
+            }
+        }
+    });
+
+});