@ibgib/core-gib 0.1.12 → 0.1.14

package/src/witness/space/reconciliation-space/reconciliation-space-helper.mts.OLD.md

@@ -0,0 +1,125 @@
+import { extractErrorMsg } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { getIbGibAddr } from "@ibgib/ts-gib/dist/helper.mjs";
+import {
+    IbGibAddr, TransformOpts, TransformOpts_Mut8, TransformOpts_Rel8,
+    TransformResult,
+} from "@ibgib/ts-gib/dist/types.mjs";
+import { mut8 } from "@ibgib/ts-gib/dist/V1/transforms/mut8.mjs";
+import { rel8 } from "@ibgib/ts-gib/dist/V1/transforms/rel8.mjs";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+
+/**
+ * iteratively (recursively) apply transforms in
+ * `dnaAddrsToApplyToStoreVersion` to the store's version of the ibgib,
+ * keeping track of all dependencies used/created.  ibgibs that we create
+ * along the way that we'll set to createdIbGibs to include dna,
+ * intermediate ibGibs, and newer versions of the source.
+ *
+ * populates the given `createdibGibs_Running` array, INCLUDING THE MOST
+ * RECENT IBGIB THAT WILL BE RETURNED BY THE FUNCTION.
+ *
+ * @returns the final ibgib produced from the transform applications.
+ */
+export async function applyTransforms({
+    src,
+    createdIbGibs_Running,
+    dnaAddrsToApplyToStoreVersion,
+    allLocalIbGibs,
+}: {
+    /**
+     * Most recent src to which we will apply the given
+     * `dnaAddrsToApplyToStoreVersion`.
+     */
+    src: IbGib_V1,
+    /**
+     * This will be populated through recursive iterations while applying
+     * dnas. Everything, including new dnas, new intermediate ibgibs, and
+     * new "src" ibgibs will be added to this before the final recursive
+     * call returns the final produced (out) ibgib.
+     */
+    createdIbGibs_Running: IbGib_V1[],
+    /**
+     * Transform addresses whose ibgib will be applied to the given `src`.
+     * This will be reduced by one per each recursive call to this function
+     * that is made.
+     */
+    dnaAddrsToApplyToStoreVersion: IbGibAddr[],
+    /**
+     * Should contain the dna ibGibs that are given in
+     * `dnaAddrsToApplyToStoreVersion`
+     */
+    allLocalIbGibs: IbGib_V1[],
+}): Promise<IbGib_V1> {
+    const lc = `[${applyTransforms.name}]`;
+    try {
+        if (dnaAddrsToApplyToStoreVersion.length > 0) {
+            const dnaAddrToApply = dnaAddrsToApplyToStoreVersion.splice(0, 1)[0];
+            // we expect this dna ibgib to supplied to us, but need to check
+            const dnaIbGib_IntermediateArray =
+                allLocalIbGibs.filter(x => getIbGibAddr({ ibGib: x }) === dnaAddrToApply);
+            let dnaIbGib: IbGib_V1;
+            if (dnaIbGib_IntermediateArray.length === 1) {
+                dnaIbGib = dnaIbGib_IntermediateArray[0];
+            } else if (dnaIbGib_IntermediateArray.length === 0) {
+                throw new Error(`dna ibGib not found in supplied allLocalIbGibs. dnaAddr: ${dnaAddrToApply}. (E: 7f56826852cf48a79ab8af16bf27e284)`);
+            } else {
+                // more than one ibgib with the dna address?
+                throw new Error(`More than one ibGib in allLocalIbGibs with the dna address of ${dnaAddrToApply}? (E: a726134f4cc14a4fb2ed2d39d22af17c)(UNEXPECTED)`);
+            }
+
+            // we have our dna to apply, so do so against the incoming src
+            // any transform options is actually the dna.data plus src info.
+            let argTransform = dnaIbGib.data as TransformOpts<IbGib_V1>;
+            argTransform.src = src;
+            argTransform.srcAddr = getIbGibAddr({ ibGib: src });
+            let resTransform: TransformResult<IbGib_V1>;
+            switch (argTransform.type) {
+                case 'mut8':
+                    resTransform = await mut8(argTransform as TransformOpts_Mut8<IbGib_V1, any>);
+                    break;
+                case 'rel8':
+                    resTransform = await rel8(argTransform as TransformOpts_Rel8<IbGib_V1>);
+                    break;
+                case 'fork':
+                    throw new Error(`fork transform not expected. atow only a single fork is expected at the beginning of the lifetime of a tjp ibgib. This fork defines the uniqueness of the tjp ibgib. When merging another tjp ibgib, we would only expect update transforms to be mut8 or rel8. (E: f8ad6996ac5545edad2d58a293d37d94)`);
+                default:
+                    throw new Error(`unknown dna argTransform.type (${argTransform.type}) for dna address: ${dnaAddrToApply}.  Expecting either mut8 or rel8. (fork transform is known but not expected either.) (E: 52a98db56e934e4cb42c64e2f45fa552)`);
+            }
+
+            // add intermediate ibgibs (including dna) to createdIbGibs_Running
+            (resTransform.intermediateIbGibs ?? []).forEach(x => createdIbGibs_Running.push(x));
+            (resTransform.dnas ?? []).forEach(x => createdIbGibs_Running.push(x));
+            createdIbGibs_Running.push(resTransform.newIbGib);
+
+            // not 100% but I believe the created dna should deep equal our
+            // incoming dna that we applied. so we'll warn if it doesn't.
+            // (ibgib addresses matching necessitates deep equal)
+            if ((resTransform.dnas ?? []).length > 0) {
+                if (!resTransform.dnas!.some(x => getIbGibAddr(x) === dnaAddrToApply)) {
+                    console.warn(`${lc}(UNEXPECTED) Expected to generate exact dna that we applied in transform. dnaAddr: ${dnaAddrToApply} (W: 4a364c0b5d8d46c8af6bd540915fd973)`);
+                }
+            } else {
+                console.warn(`${lc}(UNEXPECTED) expected resTransform to include generated dna. dnaAddr: ${dnaAddrToApply}(W: 9648e2d5c40d42b7b9fb7efb09c5b13a)`)
+            }
+
+
+            // call recursively
+            return await applyTransforms({
+                src: resTransform.newIbGib,
+                createdIbGibs_Running,
+                dnaAddrsToApplyToStoreVersion,
+                allLocalIbGibs,
+            });
+        } else {
+            // no more dna to apply.
+            // createdIbGibs_Running should be populated
+            if (createdIbGibs_Running.length === 0) {
+                console.warn(`${lc} no dna transforms to apply but createdIbGibs_Running is empty. Dna is expected to start with at least one transform, otherwise don't call this function. (W: 52c7f2f6bd7e4bd0b31f53611b90268b)(UNEXPECTED)`)
+            }
+            return src;
+        }
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}

package/src/witness/space/space-base-v1.mts

@@ -1,21 +1,20 @@
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 
-
+import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
 import { WitnessBase_V1, } from '../witness-base-v1.mjs';
 import {
-    IbGibSpace, IbGibSpaceData, IbGibSpaceOptionsCmd,
-    IbGibSpaceOptionsCmdModifier, IbGibSpaceOptionsData, IbGibSpaceOptionsIbGib,
-    IbGibSpaceOptionsRel8ns, IbGibSpaceRel8ns, IbGibSpaceResultData,
-    IbGibSpaceResultIbGib, IbGibSpaceResultRel8ns
-} from '../../witness/space/space-types.mjs';
-import { getSpaceResultMetadata } from '../../witness/space/space-helper.mjs';
-import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
-// import { argy_, resulty_ } from '../witness-helper.mjs';
+    GetDependencyGraphResultData, IbGibSpace, IbGibSpaceData,
+    IbGibSpaceOptionsCmd, IbGibSpaceOptionsCmdModifier, IbGibSpaceOptionsData,
+    IbGibSpaceOptionsIbGib, IbGibSpaceOptionsRel8ns, IbGibSpaceRel8ns,
+    IbGibSpaceResultData, IbGibSpaceResultIbGib, IbGibSpaceResultRel8ns
+} from './space-types.mjs';
+import { getSpaceResultMetadata } from './space-helper.mjs';
+import { getDependencyGraph, GetGraphOptions } from '../../common/other/graph-helper.mjs';
 import { argy_, resulty_ } from '../../witness/witness-helper.mjs';
-// import { IbGibCacheService } from '../../types/ibgib.mjs';
 import { IbGibCacheService } from '../../common/cache/cache-types.mjs';
-import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
 
@@ -139,6 +138,8 @@ export abstract class SpaceBase_V1<
                     }
                 } else if (cmdModifiers.includes('addrs')) {
                     return this.getAddrs(arg);
+                } else if (cmdModifiers.includes('dependency-graph')) {
+                    return this.getDependencyGraph(arg);
                 } else {
                     return this.get(arg);
                 }
@@ -280,6 +281,55 @@ export abstract class SpaceBase_V1<
         throw new Error(`${lc} not implemented in base class`);
     }
 
+    /**
+     * gets the entire dependency graph(s) of incoming addr(s).
+     * 
+     * NOTE: Caller will have to manually convert the result.ibGibs to a flag
+     * ibgib graph to match the existing {@link getDependencyGraph} return if
+     * desired. This should be a trivial conversion though, as the keys to the
+     * flat graph are just the {@link getIbGibAddr} on the ibGib itself.
+     * 
+     * @returns resulty ibgib with {@link GetDependencyGraphResultData}
+     */
+    protected getDependencyGraph(arg: TOptionsIbGib): Promise<TResultIbGib | undefined> { return this.getDependencyGraphImpl(arg); }
+    /**
+     * Default implementation of getDependencyGraph uses the helper function
+     * {@link getDependencyGraph} in space-helpers.mts.
+     * 
+     * Override this in subclasses for optimized behavior (e.g. Postgres).
+     */
+    protected async getDependencyGraphImpl(arg: TOptionsIbGib): Promise<TResultIbGib | undefined> {
+        const lc = `${this.lc}[${this.getDependencyGraphImpl.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 0e5fe807a0169224781f6c2833f34826)`); }
+            if (!arg.data) { throw new Error(`(UNEXPECTED) arg.data falsy? (E: 45eba816295a97a0e55f981861a03f26)`); }
+            if ((arg.data.ibGibAddrs ?? []).length === 0) {
+                throw new Error(`arg.data.ibGibAddrs is falsy/empty (E: 70adc939c7b80c9938d8fa18fd7c5826)`);
+            }
+            const opts: GetGraphOptions = {
+                space: this,
+                ibGibAddrs: arg.data.ibGibAddrs!,
+                live: (arg.data as any).live || true,
+            };
+            const graph = await getDependencyGraph(opts);
+            const ibGibs = Object.values(graph) as TIbGib[];
+            const resultData: GetDependencyGraphResultData = {
+                optsAddr: getIbGibAddr({ ibGib: arg }),
+                count: ibGibs.length,
+                addrs: Object.keys(graph),
+            };
+            return this.resulty({
+                resultData: resultData as any as TResultData,
+                ibGibs,
+            });
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
     /**
      * Centralized location for general argument validation for a given witness.
      *
@@ -362,7 +412,7 @@ export abstract class SpaceBase_V1<
             }
             return errors;
         } catch (error) {
-            console.error(`${lc} ${error.message}`);
+            console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;
         } finally {
             if (errors?.length > 0) { console.error(`${lc} errors: ${errors}`); }

package/src/witness/space/space-helper.mts

@@ -25,7 +25,8 @@ import { TagData_V1, TagIbGib_V1 } from '../../common/tag/tag-types.mjs';
 import { BOOTSTRAP_DATA_DEFAULT_SPACE_ID_KEY, BOOTSTRAP_DATA_KNOWN_SPACE_IDS_KEY, BOOTSTRAP_IBGIB_ADDR } from './bootstrap/bootstrap-constants.mjs';
 import {
     SpaceLockScope, IbGibSpaceLockIbGib, SpaceId, IbGibSpaceLockOptions, TxId,
-    IbGibSpaceResultIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns, SpaceType, SpaceSubtype, VALID_SPACE_TYPES, VALID_SPACE_SUBTYPES, IbGibSpaceData
+    IbGibSpaceResultIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns, SpaceType, SpaceSubtype, VALID_SPACE_TYPES, VALID_SPACE_SUBTYPES, IbGibSpaceData,
+    IbGibSpaceOptionsCmd, IbGibSpaceOptionsCmdModifier,
 } from './space-types.mjs';
 import { getAppIb, } from '../app/app-helper.mjs';
 import { AppData_V1, AppIbGib_V1 } from '../app/app-types.mjs';
@@ -3430,3 +3431,51 @@ export function spaceNameIsValid(name: string): boolean {
         return false;
     }
 }
+
+/**
+ * wrapper for getting dependency graph from a space.
+ * 
+ * NOTE: This calls the witness space with the command. This is NOT the
+ * same as the logic helper in graph-helper.mts which performs the graph
+ * traversal logic potentially in-memory or naively.
+ */
+export async function getDependencyGraph({
+    space,
+    ibGibAddrs,
+    live,
+}: {
+    space: IbGibSpaceAny,
+    ibGibAddrs: IbGibAddr[],
+    live?: boolean,
+}): Promise<{ [addr: string]: IbGib_V1 } | null> {
+    const lc = `[${getDependencyGraph.name}]`;
+    try {
+        if (!space) { throw new Error(`space required (E: 8f2441c099084898953153549725f778)`); }
+        if ((ibGibAddrs ?? []).length === 0) { throw new Error(`ibGibAddrs required (E: 9c3b8853609841808093153927649526)`); }
+
+        const argData: any = {
+            cmd: IbGibSpaceOptionsCmd.get,
+            cmdModifiers: [IbGibSpaceOptionsCmdModifier.dependencyGraph],
+            ibGibAddrs,
+            live,
+        };
+        const arg = await space.argy({ argData });
+
+        const result = await space.witness(arg);
+        if (result?.data?.success) {
+            const graph: { [addr: string]: IbGib_V1 } = {};
+            if (result.ibGibs) {
+                for (const ibGib of result.ibGibs) {
+                    const addr = getIbGibAddr({ ibGib });
+                    graph[addr] = ibGib;
+                }
+            }
+            return graph;
+        } else {
+            return null;
+        }
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}

package/src/witness/space/space-respec-helper.mts

@@ -29,7 +29,8 @@ import { Factory_V1 as factory } from '@ibgib/ts-gib/dist/V1/factory.mjs';
 
 import {
     deleteFromSpace, getFromSpace, getLatestAddrs, parseSpaceIb,
-    persistTransformResult, putInSpace, registerNewIbGib
+    persistTransformResult, putInSpace, registerNewIbGib,
+    getDependencyGraph,
 } from "./space-helper.mjs";
 import { IbGibSpaceAny } from "./space-base-v1.mjs";
 import { IbGibTimelineUpdateInfo } from '../../common/other/other-types.mjs';

package/src/witness/space/space-types.mts

@@ -226,7 +226,7 @@ export const IbGibSpaceOptionsCmd = {
  * Flags to affect the command's interpretation.
  */
 export type IbGibSpaceOptionsCmdModifier =
-    'can' | 'addrs' | 'latest' | 'watch' | 'unwatch' | 'tjps';
+    'can' | 'addrs' | 'latest' | 'watch' | 'unwatch' | 'tjps' | 'dependency-graph';
 /**
  * Flags to affect the command's interpretation.
  */
@@ -266,6 +266,10 @@ export const IbGibSpaceOptionsCmdModifier = {
      * Get the tjp ibgibs/addrs for given ibgib(s)
      */
     tjps: 'tjps' as IbGibSpaceOptionsCmdModifier,
+    /**
+     * Modifies the get command to retrieve a dependency graph.
+     */
+    dependencyGraph: 'dependency-graph' as IbGibSpaceOptionsCmdModifier,
 }
 
 /** Information for interacting with spaces. */
@@ -485,3 +489,11 @@ export interface IbGibSpaceLockIbGib
  * Marker type to indicate that a string is meant to be a transmission id.
  */
 export type TxId = 'string';
+
+/**
+ * we have a getDependencyGraph wrapper in the space base. This is the type of
+ * that's result data.
+ */
+export interface GetDependencyGraphResultData extends IbGibSpaceResultData {
+    count: number;
+}

package/tmp.md

@@ -1,11 +1,5 @@
-OK, ty. The space-wide sync approach is not tenable. That is like trying to sync Alice's entire logical drive with Bob's entire logical drive instead of a particular folder on the drive. Your thinking that a single Domain IbGib does not contain many timelines is faulty. A dependency graph of a "single" domain may contain multiple, or even many/a great many, timelines. Think of this like in set theory and we are creating an isomorphic projection of nodes. I say isomorphic and not homomorphic, because we may have to do merges for timelines, so it really is a "one-way" projection. Though obviously, with "sync" being bi-directional, we are ultimately converging on both endpoints having "equivalent" timelines (there may be orphans on one and/or the other after merges, with either endpoint effectively doing a "rebase"). So our sync process has to start with getting a "live" dependency graph of a single domain ibgib. We can actually do multiple domain ibgibs, and then unify the entire dependency graph in the sync transmission ibgib, but I think it's best to just build for the single ibgib scenario. You can look at@beautifulMention, but I would really recommend looking at the entire @beautifulMentionfile. This is a non-trivial recursive function, but you should be able to fully grok it by looking at both the jsdocs/comments in that file and the code itself. Always look at the code itself of course!
+OK nice sketch! We need to drastically wrangle in the complexity to nice methods, like we have with `createSyncMsgStone`, `evolveSyncSagaIbGib`, etc. 
 
-That dependency graph comes in the form a @beautifulMention as defined by this:
-
-```
-/**
- * Map of addr -> ibGib
- */
-export type FlatIbGibGraph = { [addr: string]: IbGib_V1 };
-```
+Also, we need to get this to a finite state machine-like execution. The `sync` method should do the initial setup regarding the saga info object, the temp space, and the session identity. But the analyzeTimelines is specific to the init frame and should be refactored into the FSM method specific to init. So we need to separate the saga meta-setup and the saga initial frame. 
 
+Also, I don't think we can just naively call `updates$.complete()` like that at the end. This will end up being a recursive or do/while loop with msg/response with the peer.