@ibgib/core-gib 0.0.65 → 0.0.67

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

@@ -14,7 +14,7 @@ import {
     GetIbGibOpts, GetIbGibResult,
     PutIbGibOpts, PutIbGibResult
 } from '../../../common/other/other-types.mjs';
-import { SyncSagaInfo, } from '../../../witness/space/outer-space/outer-space-types.mjs';
+import { SyncSagaInfo, SyncSpaceIbGib, } from '../../../witness/space/outer-space/outer-space-types.mjs';
 import { SpaceId } from '../../../witness/space/space-types.mjs';
 import { IbGibSpaceAny } from '../../../witness/space/space-base-v1.mjs';
 import { IbGibTimelineUpdateInfo, SpecialIbGibType } from '../../../common/other/other-types.mjs';
@@ -37,10 +37,21 @@ export interface CreateLocalSpaceOptions {
     logalot?: number | boolean;
 }
 
+/**
+ * factory function that takes a dto ibgib (one without a .witness function for
+ * behavior) and creates/loads its corresponding witness.
+ */
 export type DtoToSpaceFunction = (spaceDto: IbGib_V1) => Promise<IbGibSpaceAny>;
 export type ZeroSpaceFactoryFunction = () => IbGibSpaceAny;
 export type LocalSpaceFactoryFunction = (opts: CreateLocalSpaceOptions) => Promise<IbGibSpaceAny | undefined>;
 
+/**
+ * two levels deep map of space type.subtype -> factory function.
+ *
+ * @see {@link DtoToSpaceFunction}
+ */
+export type SpaceFactoryFnMap = { [type: string]: { [subtype: string]: DtoToSpaceFunction } }
+
 export interface MetaspaceInitializeOptions {
     /**
      * If provided, will initialize using this spaceName if creating a new local
@@ -544,24 +555,24 @@ export interface MetaspaceService {
         dontPrompt?: boolean,
         space: IbGibSpaceAny,
     }): Promise<string>;
-    unwrapEncryptedSyncSpace(arg: {
-        encryptedSpace: IbGibSpaceAny,
-        fnPromptPassword: (title: string, msg: string) => Promise<string | null>,
-        dontPrompt?: boolean,
-        space?: IbGibSpaceAny,
-    }): Promise<IbGibSpaceAny>;
-    getSyncSpaces(arg: {
-        unwrapEncrypted: boolean,
-        createIfNone: boolean,
-        /**
-         * If true, don't prompt the user if we don't have it already cached.
-         *
-         * We don't want the user to hit the page and then always have to type in
-         * the password, just because my password code sucks atow.
-         */
-        dontPrompt?: boolean,
-        space?: IbGibSpaceAny,
-    }): Promise<IbGibSpaceAny[]>;
+    // unwrapEncryptedSyncSpace(arg: {
+    //     encryptedSpace: IbGibSpaceAny,
+    //     fnPromptPassword: (title: string, msg: string) => Promise<string | null>,
+    //     dontPrompt?: boolean,
+    //     space?: IbGibSpaceAny,
+    // }): Promise<IbGibSpaceAny>;
+    // getSyncSpaces(arg: {
+    //     // unwrapEncrypted: boolean,
+    //     createIfNone: boolean,
+    //     /**
+    //      * If true, don't prompt the user if we don't have it already cached.
+    //      *
+    //      * We don't want the user to hit the page and then always have to type in
+    //      * the password, just because my password code sucks atow.
+    //      */
+    //     dontPrompt?: boolean,
+    //     space?: IbGibSpaceAny,
+    // }): Promise<SyncSpaceIbGib[]>;
     getAppRobbotIbGibs(arg: {
         createIfNone: boolean,
         fnPromptRobbot: (space: IbGibSpaceAny, ibGib: RobbotIbGib_V1 | null) => Promise<RobbotPromptResult | undefined>;
@@ -581,55 +592,20 @@ export interface MetaspaceService {
          * ibgibs to be synced.
          */
         dependencyGraphIbGibs?: IbGib_V1[],
-        // confirm?: boolean,
+        /**
+         * sync space witnesses that we are going to send a put+sync cmd with
+         * the given {@link dependencyGraphIbGibs}.
+         *
+         * Note these are witnesses ({@link IbGibSpaceAny}) and not just the
+         * {@link SyncSpaceIbGib} interface, which is itself only an ibgib shape.
+         */
+        syncSpaceIbGibs: IbGibSpaceAny[],
         // /**
         //  * If true, will watch ibgibs in dependency graph that have timelines
         //  * (tjps) to keep in sync going forward.
         //  */
         // watch?: boolean,
-        /**
-         * if provided, these will determine which outerspace(s) we will sync
-         * the {@link dependencyGraphIbGibs} with.
-         */
-        outerspaceIds?: SpaceId[],
-        /**
-         * The meat of the sync process is tracked via a status within the sync
-         * spaces themselves. I'm addign this fn to track the pre and post progress
-         * stuff, since decrypting takes some time, and building the dependency
-         * graphs takes time. Both of these happen before the actual syncing occurs
-         * in the spaces.
-         */
-        fnPreSyncProgress?: (msg: string) => Promise<void>,
     }): Promise<SyncSagaInfo[] | undefined>;
-    // /**
-    //  * Prompts the user to select a new picture for the given `picIbGib`.
-    //  *
-    //  * If the user does select one, this creates the appropriate ibgibs (pic,
-    //  * binary, dependencies), saves them, registers the new pic (but not the bin)
-    //  * in the given `space` if specified, else in the current `localUserSpace`.
-    //  */
-    // updatePic(arg: {
-    //   /**
-    //    * picIbGib to update with a new image.
-    //    */
-    //   picIbGib: PicIbGib_V1,
-    //   /**
-    //    * space within which we are working, i.e., where the incoming `picIbGib` is
-    //    * and where we will save any new ibgibs.
-    //    */
-    //   space?: IbGibSpaceAny,
-    // }): Promise<void>;
-    // updateComment(arg: {
-    //   /**
-    //    * commentIbGib to update with a new text
-    //    */
-    //   commentIbGib: CommentIbGib_V1,
-    //   /**
-    //    * space within which we are working, i.e., where the incoming `commentIbGib` is
-    //    * and where we will save any new ibgibs.
-    //    */
-    //   space?: IbGibSpaceAny,
-    // }): Promise<void>;
 
     /**
      * creates a new local space with the given `fnLocalSpaceFactory` function

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

@@ -14,10 +14,13 @@ import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs
 
 import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
 import { SpaceType, SpaceSubtype, VALID_SPACE_SUBTYPES, VALID_SPACE_TYPES, } from '../space-types.mjs';
-import { StatusCode, StatusIbInfo, } from './outer-space-types.mjs';
+import { StatusCode, StatusIbInfo, SyncSpaceIbGib, } from './outer-space-types.mjs';
 import { OUTER_SPACE_DEFAULT_IB_DELIMITER } from './outer-space-constants.mjs';
-import { EncryptionIbGib_V1 } from '../../../common/encrypt/encrypt-types.mjs';
-import { SecretIbGib_V1 } from '../../../common/secret/secret-types.mjs';
+import { IbGibSpaceAny } from '../space-base-v1.mjs';
+import { getSpecialRel8dIbGibs } from '../space-helper.mjs';
+import { SpecialIbGibType } from '../../../common/other/other-types.mjs';
+import { SYNC_SPACE_REL8N_NAME } from '../space-constants.mjs';
+import { SpaceFactoryFnMap } from '../metaspace/metaspace-types.mjs';
 
 
 /**
@@ -49,7 +52,7 @@ export function getStatusIb({
 
         return `status ${sagaId} ${statusCode} ${spaceType} ${spaceSubtype}`;
     } catch (error) {
-        console.error(`${lc} ${error.message}`);
+        console.error(`${lc} ${extractErrorMsg(error)}`);
         throw error;
     }
 }
@@ -91,7 +94,88 @@ export function getStatusIbInfo({
 
         return { statusCode, spaceType, spaceSubtype, sagaId, delimiter };
     } catch (error) {
-        console.error(`${lc} ${error.message}`);
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}
+
+export async function getSyncSpaces({
+    space,
+}: {
+    space: IbGibSpaceAny,
+}): Promise<SyncSpaceIbGib[]> {
+    const lc = `[${getSyncSpaces.name}]`;
+    try {
+        if (!space) { throw new Error(`space required. (E: c03f80eca6b045b9a73b0aafa44cdf26)`); }
+        let syncSpaces = await getSpecialRel8dIbGibs<SyncSpaceIbGib>({
+            type: SpecialIbGibType.outerspaces,
+            rel8nName: SYNC_SPACE_REL8N_NAME,
+            space,
+        });
+        return syncSpaces;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}
+
+/**
+ * gets the sync space ibgibs referenced in the given local {@link localSpace}
+ * and loads them into their corresponding witness classes.
+ *
+ * note: atow (03/2024) this throws if a factory function isn't found for ANY of
+ * the sync spaces found. later on, when multiple kinds of sync spaces are in
+ * existence, this behavior should change because it would be quite possible
+ * that we have multiple spaces that may not have a loaded factory function
+ * available.
+ *
+ * @see {@link SpaceFactoryFnMap}
+ *
+ * @returns sync space witnesses
+ */
+export async function getSyncSpaces_witnesses({
+    localSpace,
+    spaceFactoryFns,
+}: {
+    /**
+     * user's local space that contains references to outer space "proxy"
+     * ibgibs.
+     */
+    localSpace: IbGibSpaceAny,
+    /**
+     * factory function map (by type/subtype) that generates the space witnesses
+     * from the space dtos.
+     *
+     * @see {@link SpaceFactoryFnMap}
+     */
+    spaceFactoryFns: SpaceFactoryFnMap,
+}): Promise<IbGibSpaceAny[]> {
+    const lc = `[${getSyncSpaces_witnesses.name}]`;
+    try {
+        if (!localSpace) { throw new Error(`localSpace required. (E: c03f80eca6b045b9a73b0aafa44cdf26)`); }
+        let resSpaceWitnesses: IbGibSpaceAny[] = [];
+
+        const syncSpaceDtos = await getSyncSpaces({ space: localSpace });
+        for (let i = 0; i < syncSpaceDtos.length; i++) {
+            const syncSpaceDto = syncSpaceDtos[i];
+            if (!syncSpaceDto.data) { throw new Error(`(UNEXPECTED) syncSpaceDto.data falsy? (E: 5404f124b8bb781c0a52b3cc9f8e6524)`); }
+            const { type, subtype } = syncSpaceDto.data;
+            if (!type) { throw new Error(`(UNEXPECTED) syncSpaceDto.data.type falsy? (E: b3461e0df562d301fc84d68d95f91424)`); }
+            if (!subtype) { throw new Error(`(UNEXPECTED) syncSpaceDto.data.subtype falsy? (E: 524c471119564b4b817261f9e1edcafb)`); }
+            const fnFactory_typeSubset = spaceFactoryFns[syncSpaceDto.data.type] ?? {};
+            const fnFactory = fnFactory_typeSubset[syncSpaceDto.data.subtype];
+            if (!fnFactory) { throw new Error(`(UNEXPECTED) no factory function found for type (${type}) and subtype (${subtype})? (E: fd726f9049ade511f679d1de621dec24)`); }
+            const spaceWitness = await fnFactory(syncSpaceDto);
+            resSpaceWitnesses.push(spaceWitness);
+        }
+
+        if (syncSpaceDtos.length !== resSpaceWitnesses.length) {
+            throw new Error(`(UNEXPECTED) syncSpaceDtos.length !== resSpaceWitnesses.length? (E: c85b1c93fce972a57683da727e6dc224)`);
+        }
+
+        return resSpaceWitnesses;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
         throw error;
     }
 }

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

@@ -125,9 +125,16 @@ export interface OuterSpaceData extends IbGibSpaceData {
 }
 
 export interface OuterSpaceRel8ns extends IbGibSpaceRel8ns {
+    /**
+     * the ciphertext will contain private data that is typed per use case (per
+     * concrete implementation).
+     */
     [CIPHERTEXT_REL8N_NAME]?: IbGibAddr[];
 }
 
+/**
+ *
+ */
 export interface OuterSpaceIbGib
     extends IbGib_V1<OuterSpaceData, OuterSpaceRel8ns> {
 }
@@ -567,6 +574,9 @@ export interface SagaInfo<
     sagaId: string;
     /**
      * Reference to the space with which we're communicating.
+     *
+     * Note that this is a witness not just an ibgib data shape. so you will be
+     * able to pass in args to witness to this space.
      */
     outerSpace: IbGibSpaceAny;
     spaceId: string;

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

@@ -51,6 +51,7 @@ import { validateBootstrapIbGib } from './bootstrap/bootstrap-helper.mjs';
 import { BootstrapData, BootstrapIbGib, BootstrapRel8ns } from './bootstrap/bootstrap-types.mjs';
 import { newUpMetaStone } from '../../common/meta-stone/meta-stone-helper.mjs';
 import { WITNESS_ATOM } from '../witness-constants.mjs';
+import { SyncSpaceIbGib } from './outer-space/outer-space-types.mjs';
 
 let logalot = GLOBAL_LOG_A_LOT;
 
@@ -325,26 +326,6 @@ export async function persistTransformResult({
     }
 }
 
-export async function getSyncSpaces({
-    space,
-}: {
-    space: IbGibSpaceAny,
-}): Promise<IbGibSpaceAny[]> {
-    const lc = `[${getSyncSpaces.name}]`;
-    try {
-        if (!space) { throw new Error(`space required. (E: c03f80eca6b045b9a73b0aafa44cdf26)`); }
-        let syncSpaces = await getSpecialRel8dIbGibs<IbGibSpaceAny>({
-            type: "outerspaces",
-            rel8nName: SYNC_SPACE_REL8N_NAME,
-            space,
-        });
-        return syncSpaces;
-    } catch (error) {
-        console.error(`${lc} ${error.message}`);
-        throw error;
-    }
-}
-
 export async function getSpecialRel8dIbGibs<TIbGib extends IbGib_V1 = IbGib_V1>({
     type,
     rel8nName,